Meridian Base — настольные базы данных

-- Реестр объектов / Object registry
CREATE TABLE meridian_objects (
  id INTEGER PRIMARY KEY,
  kind TEXT NOT NULL CHECK(kind IN ('table','linked_table','query','form','report','macro','script','module','group')),
  name TEXT NOT NULL,                       -- отображаемое имя / display name
  sql_name TEXT,                            -- имя в SQLite (для таблиц/представлений) / SQLite identifier
  group_id INTEGER REFERENCES meridian_objects(id),   -- пользовательская группа навигатора
  description TEXT, hidden INTEGER DEFAULT 0, system INTEGER DEFAULT 0,
  created TEXT NOT NULL, modified TEXT NOT NULL, created_by TEXT, modified_by TEXT,
  properties TEXT,                          -- JSON: произвольные свойства (ширины столбцов, порядок, формат)
  UNIQUE(kind, name)
);

-- Метаданные столбцов (то, чего нет в SQLite): подтипы, подписи, маски, подстановки
-- / Column metadata beyond SQLite types
CREATE TABLE meridian_columns (
  table_id INTEGER NOT NULL REFERENCES meridian_objects(id) ON DELETE CASCADE,
  name TEXT NOT NULL, ord INTEGER NOT NULL,
  subtype TEXT NOT NULL,                    -- short_text|long_text|rich_text|byte|integer|long|bigint|single|double|decimal|currency|
                                            -- datetime|date|time|boolean|autonumber|attachment|hyperlink|calculated|guid|multi|image|json
  size INTEGER, precision INTEGER, scale INTEGER,
  caption TEXT, description TEXT, format TEXT, input_mask TEXT, default_expr TEXT,
  validation_rule TEXT, validation_text TEXT, required INTEGER DEFAULT 0, allow_zero_length INTEGER DEFAULT 1,
  lookup_id INTEGER REFERENCES meridian_lookups(id), display_width INTEGER, hidden INTEGER DEFAULT 0, align TEXT,
  PRIMARY KEY(table_id, name)
);

-- Подстановки / Lookups
CREATE TABLE meridian_lookups (
  id INTEGER PRIMARY KEY, kind TEXT CHECK(kind IN ('table','query','values')), source TEXT,   -- имя таблицы/запроса или JSON-список
  bound_column INTEGER DEFAULT 1, display_columns TEXT, column_widths TEXT, limit_to_list INTEGER DEFAULT 1,
  allow_multiple INTEGER DEFAULT 0, row_source_sql TEXT
);

-- Связи и целостность (дублируют FOREIGN KEY для редактирования и для связанных таблиц)
-- / Relationships (mirror of FOREIGN KEY, plus linked tables)
CREATE TABLE meridian_relationships (
  id INTEGER PRIMARY KEY, name TEXT UNIQUE,
  parent_table TEXT NOT NULL, parent_columns TEXT NOT NULL,     -- JSON ["id"]
  child_table TEXT NOT NULL, child_columns TEXT NOT NULL,       -- JSON ["customer_id"]
  kind TEXT CHECK(kind IN ('one_to_many','one_to_one','many_to_many')) DEFAULT 'one_to_many',
  enforce INTEGER DEFAULT 1, cascade_update INTEGER DEFAULT 0, cascade_delete INTEGER DEFAULT 0,
  join_type TEXT CHECK(join_type IN ('inner','left','right')) DEFAULT 'inner',
  diagram_pos TEXT                                              -- JSON: позиции таблиц на схеме
);

-- Запросы / Queries
CREATE TABLE meridian_queries (
  object_id INTEGER PRIMARY KEY REFERENCES meridian_objects(id) ON DELETE CASCADE,
  kind TEXT NOT NULL CHECK(kind IN ('select','totals','crosstab','update','append','delete','make_table','union','passthrough','ddl')),
  design_xml TEXT,                          -- модель QBE (urn:meridian:office:base:1), NULL для чистого SQL
  sql TEXT NOT NULL,                        -- сгенерированный или введённый SQL / generated or hand-written
  params TEXT,                              -- JSON [{name,type,prompt}]
  source TEXT,                              -- NULL = локально, иначе id связи сервера / NULL = local
  properties TEXT                           -- JSON: distinct, top, timeout, ...
);

-- Формы / Forms (XML)
CREATE TABLE meridian_forms (
  object_id INTEGER PRIMARY KEY REFERENCES meridian_objects(id) ON DELETE CASCADE,
  form_xml TEXT NOT NULL,                   -- urn:meridian:office:base:1 <form>
  record_source TEXT, view TEXT CHECK(view IN ('single','continuous','datasheet','split')) DEFAULT 'single',
  thumbnail BLOB
);

-- Отчёты / Reports (XML)
CREATE TABLE meridian_reports (
  object_id INTEGER PRIMARY KEY REFERENCES meridian_objects(id) ON DELETE CASCADE,
  report_xml TEXT NOT NULL, record_source TEXT, page_setup TEXT, thumbnail BLOB
);

-- Макросы и скрипты / Macros and scripts
CREATE TABLE meridian_macros (object_id INTEGER PRIMARY KEY REFERENCES meridian_objects(id) ON DELETE CASCADE, macro_xml TEXT NOT NULL);
CREATE TABLE meridian_scripts (object_id INTEGER PRIMARY KEY REFERENCES meridian_objects(id) ON DELETE CASCADE,
  language TEXT CHECK(language IN ('ts','js','py')) DEFAULT 'ts', source TEXT NOT NULL, compiled BLOB, signature BLOB, permissions TEXT);

-- Связанные источники / Linked sources
CREATE TABLE meridian_links (
  id INTEGER PRIMARY KEY, name TEXT UNIQUE, driver TEXT CHECK(driver IN ('postgres','mysql','mssql','odbc','sqlite','csv','xlsx')),
  conn TEXT NOT NULL,                       -- строка подключения без пароля / connection string without secret
  credential_ref TEXT,                      -- ключ в хранилище ОС / OS keystore key
  options TEXT
);
CREATE TABLE meridian_linked_tables (
  object_id INTEGER PRIMARY KEY REFERENCES meridian_objects(id) ON DELETE CASCADE,
  link_id INTEGER REFERENCES meridian_links(id), remote_schema TEXT, remote_name TEXT, remote_pk TEXT,
  columns_cache TEXT, cached_at TEXT, read_only INTEGER DEFAULT 0
);

-- Вложения / Attachments
CREATE TABLE meridian_attachments (
  id INTEGER PRIMARY KEY, table_name TEXT NOT NULL, column_name TEXT NOT NULL, row_id INTEGER NOT NULL,
  file_name TEXT NOT NULL, mime_type TEXT, size INTEGER, sha256 TEXT, data BLOB, thumb BLOB, added TEXT
);
CREATE INDEX meridian_attachments_row ON meridian_attachments(table_name, column_name, row_id);

-- Настройки базы / Database settings
CREATE TABLE meridian_settings (key TEXT PRIMARY KEY, value TEXT);
-- ключи: startup.form, startup.title, startup.icon, startup.hide_navigator, app.version, schema.strict, audit.enabled, ...

-- Журнал изменений (опционально) / Audit log (optional)
CREATE TABLE meridian_audit (id INTEGER PRIMARY KEY, ts TEXT, user TEXT, table_name TEXT, row_id INTEGER, op TEXT, before TEXT, after TEXT);

-- Ошибки импорта / Import errors
CREATE TABLE meridian_import_errors (id INTEGER PRIMARY KEY, run_id TEXT, row_no INTEGER, column_name TEXT, value TEXT, error TEXT);

<form xmlns="urn:meridian:office:base:1" name="Заказы" view="single" record-source="SELECT * FROM orders ORDER BY date DESC"
      allow-add="true" allow-edit="true" allow-delete="true" width="720" caption="Заказы" popup="false" modal="false"
      filter="" order-by="" default-view="single" nav-buttons="true" record-selectors="true">
  <events on-open="macro:ПриОткрытии" on-current="script:orders.ts#onCurrent" on-before-update="script:orders.ts#validate"/>
  <section kind="header" height="48" back="#F5F6F8">
    <control type="label" name="lblTitle" x="16" y="12" w="300" h="24" text="Заказ" font="Inter 18 600"/>
  </section>
  <section kind="detail" height="320">
    <control type="textbox" name="txtNumber" x="16" y="16" w="160" h="28" field="number" locked="true" tab-index="0"/>
    <control type="datepicker" name="dtDate" x="200" y="16" w="160" h="28" field="date" format="dd.MM.yyyy" default="=Date()"/>
    <control type="combobox" name="cboCustomer" x="16" y="60" w="344" h="28" field="customer_id"
             row-source="SELECT id, name FROM customers ORDER BY name" bound-column="1" columns="0;1" widths="0;320" limit-to-list="true">
      <events on-not-in-list="script:orders.ts#addCustomer"/>
    </control>
    <control type="textbox" name="txtTotal" x="16" y="104" w="160" h="28" expr="=DSum('qty*price','order_items','order_id=' &amp; [id])" format="currency" locked="true"/>
    <control type="checkbox" name="chkPaid" x="200" y="104" w="120" h="28" field="paid" caption="Оплачен"/>
    <control type="tab" name="tabs" x="16" y="148" w="688" h="160">
      <page caption="Позиции">
        <control type="subform" name="sfItems" x="8" y="8" w="664" h="130" source-object="form:Позиции заказа"
                 link-master="id" link-child="order_id" view="datasheet"/>
      </page>
      <page caption="Примечания"><control type="richtext" name="txtNotes" x="8" y="8" w="664" h="130" field="notes"/></page>
    </control>
    <control type="button" name="btnPrint" x="600" y="16" w="104" h="28" caption="Печать" icon="print">
      <events on-click="macro:OpenReport(report='Счёт', view='preview', where='id=' &amp; [id])"/>
    </control>
  </section>
  <section kind="footer" height="40"/>
</form>

<report xmlns="urn:meridian:office:base:1" name="Продажи по клиентам" record-source="qSalesByCustomer"
        page="A4" orientation="portrait" margins="20 15 20 15" columns="1" units="mm">
  <grouping>
    <level field="customer_name" order="asc" header="true" footer="true" keep-together="whole-group" repeat-header="true"/>
    <level field="date" interval="month" order="asc" header="true" footer="false"/>
    <sort field="date" order="asc"/>
  </grouping>
  <band kind="report-header" height="30"><control type="label" x="0" y="0" w="180" h="12" text="Продажи по клиентам" font="Inter 16 600"/></band>
  <band kind="page-header" height="10">
    <control type="label" x="0" y="0" w="60" h="8" text="Дата"/><control type="label" x="60" y="0" w="80" h="8" text="Товар"/>
    <control type="label" x="140" y="0" w="30" h="8" text="Сумма" align="right"/>
  </band>
  <band kind="group-header" level="1" height="12" new-page="before" force-new-page="none">
    <control type="textbox" x="0" y="2" w="180" h="8" field="customer_name" font="Inter 11 600"/>
  </band>
  <band kind="group-header" level="2" height="8"><control type="textbox" x="0" y="0" w="80" h="8" expr="=Format([date],'MMMM yyyy')"/></band>
  <band kind="detail" height="8" can-grow="true" hide-duplicates="date">
    <control type="textbox" x="0" y="0" w="60" h="8" field="date" format="dd.MM.yyyy"/>
    <control type="textbox" x="60" y="0" w="80" h="8" field="product" can-grow="true"/>
    <control type="textbox" x="140" y="0" w="30" h="8" field="amount" format="currency" align="right"/>
  </band>
  <band kind="group-footer" level="1" height="10">
    <control type="textbox" x="100" y="1" w="40" h="8" text="Итого:" align="right"/>
    <control type="textbox" x="140" y="1" w="30" h="8" expr="=Sum([amount])" format="currency" align="right" running-sum="none"/>
  </band>
  <band kind="page-footer" height="8"><control type="textbox" x="140" y="0" w="30" h="8" expr="='Стр. ' &amp; [Page] &amp; ' из ' &amp; [Pages]" align="right"/></band>
  <band kind="report-footer" height="12"><control type="textbox" x="140" y="2" w="30" h="8" expr="=Sum([amount])" format="currency" align="right"/></band>
</report>

<macro xmlns="urn:meridian:office:base:1" name="ПриОткрытии">
  <action name="SetTempVar" var="opened_at" value="=Now()"/>
  <if condition="=IsNull([Forms]![Заказы]![cboCustomer])">
    <action name="MessageBox" text="Выберите клиента" type="warning"/>
    <action name="GoToControl" control="cboCustomer"/>
  <else/>
    <action name="ApplyFilter" where="paid = 0"/>
  </if>
  <on-error goto="next"/>
</macro>

// kernel/crates/meridian-base/src/query.rs — модель QBE / QBE model
pub struct QueryDesign {
    pub kind: QueryKind,                       // Select | Totals | Crosstab | Update | Append | Delete | MakeTable | Union
    pub sources: Vec<SourceRef>,               // таблицы/запросы с псевдонимами / tables & queries with aliases
    pub joins: Vec<Join>,                      // { left, right, on: Vec<(Col, Col)>, kind: Inner|Left|Right|Full }
    pub columns: Vec<QbeColumn>,               // строки сетки по столбцам / grid columns
    pub criteria: Vec<Vec<Option<Expr>>>,      // criteria[row][col]: строки — OR, столбцы — AND / rows OR, cols AND
    pub params: Vec<Param>,
    pub distinct: bool, pub top: Option<Top>,
    pub crosstab: Option<Crosstab>,            // { row_headings, column_heading, value, agg, fixed_headings }
    pub target: Option<String>,                // для Append/MakeTable / for Append/MakeTable
}
pub struct QbeColumn {
    pub expr: Expr,                            // поле или выражение / field or expression
    pub alias: Option<String>, pub source: Option<String>,
    pub show: bool, pub sort: Option<SortDir>,
    pub total: Option<Total>,                  // GroupBy | Sum | Avg | Min | Max | Count | StDev | Var | First | Last | Expression | Where
    pub update_to: Option<Expr>,               // для Update / for Update
    pub append_to: Option<String>,             // для Append / for Append
}

// kernel/crates/meridian-db/src/backend.rs — единый интерфейс источников / unified backend trait
#[async_trait]
pub trait DbBackend: Send + Sync {
    fn dialect(&self) -> Dialect;              // Sqlite | Postgres | MySql | MsSql | Ansi
    async fn schema(&self) -> Result<Schema>;
    async fn query(&self, sql: &str, params: &[Value]) -> Result<Box<dyn Cursor>>;
    async fn execute(&self, sql: &str, params: &[Value]) -> Result<u64>;
    async fn begin(&self) -> Result<Box<dyn Transaction>>;
    fn capabilities(&self) -> Caps;            // returning, savepoints, window functions, pivot, keyset, ...
}

pub fn qbe_to_sql(q: &QueryDesign, d: Dialect) -> Result<String> {
    let mut sql = String::new();
    match q.kind {
        QueryKind::Select | QueryKind::Totals | QueryKind::Crosstab => {
            if q.kind == QueryKind::Crosstab { return crosstab_sql(q, d); }
            sql.push_str("SELECT "); if q.distinct { sql.push_str("DISTINCT "); }
            if let (Some(top), Dialect::MsSql) = (&q.top, d) { sql.push_str(&format!("TOP {} ", top.n)); }
            // Столбцы: показываемые; при итогах — агрегаты / columns: shown; totals → aggregates
            let cols: Vec<String> = q.columns.iter().filter(|c| c.show).map(|c| {
                let e = render_expr(&c.expr, d);
                let e = match c.total { Some(Total::GroupBy) | None => e, Some(Total::Expression) => e,
                    Some(t) => format!("{}({})", agg_name(t, d), e) };
                match &c.alias { Some(a) => format!("{} AS {}", e, quote_ident(a, d)), None => e }
            }).collect();
            sql.push_str(&cols.join(", "));
            sql.push_str(" FROM "); sql.push_str(&render_from(&q.sources, &q.joins, d)?);   // FULL JOIN → UNION для SQLite/MySQL
            // WHERE: условия столбцов без агрегата (или Total::Where); строки — OR, столбцы — AND
            let (where_rows, having_rows) = split_criteria(q);
            if let Some(w) = render_criteria(&where_rows, d) { sql.push_str(" WHERE "); sql.push_str(&w); }
            if q.kind == QueryKind::Totals {
                let groups: Vec<_> = q.columns.iter().filter(|c| c.total == Some(Total::GroupBy)).map(|c| render_expr(&c.expr, d)).collect();
                if !groups.is_empty() { sql.push_str(" GROUP BY "); sql.push_str(&groups.join(", ")); }
                if let Some(h) = render_criteria(&having_rows, d) { sql.push_str(" HAVING "); sql.push_str(&h); }
            }
            let order: Vec<_> = q.columns.iter().filter(|c| c.sort.is_some())
                .map(|c| format!("{} {}", c.alias.as_ref().map(|a| quote_ident(a, d)).unwrap_or_else(|| render_expr(&c.expr, d)), if c.sort == Some(SortDir::Desc) {"DESC"} else {"ASC"})).collect();
            if !order.is_empty() { sql.push_str(" ORDER BY "); sql.push_str(&order.join(", ")); }
            if let (Some(top), false) = (&q.top, d == Dialect::MsSql) { sql.push_str(&format!(" LIMIT {}", top.n)); }   // TOP N% → подзапрос с COUNT
        }
        QueryKind::Update => {
            sql.push_str(&format!("UPDATE {} SET ", render_single_source(q, d)?));
            let sets: Vec<_> = q.columns.iter().filter_map(|c| c.update_to.as_ref().map(|u| format!("{} = {}", render_expr(&c.expr, d), render_expr(u, d)))).collect();
            sql.push_str(&sets.join(", "));
            if let Some(w) = render_criteria(&q.criteria, d) { sql.push_str(" WHERE "); sql.push_str(&w); }   // UPDATE … FROM для соединений (SQLite 3.33+, PG)
        }
        QueryKind::Delete => { sql.push_str(&format!("DELETE FROM {}", render_single_source(q, d)?)); if let Some(w) = render_criteria(&q.criteria, d) { sql.push_str(" WHERE "); sql.push_str(&w); } }
        QueryKind::Append => { sql.push_str(&format!("INSERT INTO {} ({}) ", quote_ident(q.target.as_ref().unwrap(), d), append_targets(q, d))); sql.push_str(&qbe_to_sql(&q.as_select(), d)?); }
        QueryKind::MakeTable => { sql.push_str(&format!("CREATE TABLE {} AS ", quote_ident(q.target.as_ref().unwrap(), d))); sql.push_str(&qbe_to_sql(&q.as_select(), d)?); }
        QueryKind::Union => { sql = q.union_parts.iter().map(|p| qbe_to_sql(p, d)).collect::<Result<Vec<_>>>()?.join(" UNION ALL "); }
    }
    Ok(sql)
}

interface BaseApp {
  currentDb(): Database;                        // CurrentDb()
  openDatabase(path: string, opts?: { password?: string; readOnly?: boolean }): Promise<Database>;
  forms: Record<string, Form> & { open(name: string, opts?: OpenFormOptions): Promise<Form> };     // Forms!…
  reports: Record<string, Report> & { open(name: string, opts?: OpenReportOptions): Promise<Report> };
  tempVars: Record<string, unknown>;
  ui: { message(text: string, opts?: { type?: 'info'|'warning'|'error'|'question'; buttons?: ('ok'|'cancel'|'yes'|'no')[] }): Promise<string>;
        prompt(label: string, def?: string): Promise<string | null>; status(text: string): void; hourglass(on: boolean): void };
  on(event: 'databaseOpened' | 'beforeQuit', h: (e: any) => void): Disposable;
}
interface Database {
  name: string; path: string; tableDefs: TableDef[]; queryDefs: QueryDef[]; relations: Relation[];
  openRecordset(source: string, opts?: { type?: 'dynaset'|'snapshot'|'table'; params?: Record<string, unknown>; readOnly?: boolean }): Promise<Recordset>;
  execute(sql: string, params?: unknown[] | Record<string, unknown>): Promise<{ affected: number; lastId?: number }>;
  query<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<T[]>;   // небольшие выборки целиком / small result sets
  lookup(field: string, table: string, where?: string): Promise<unknown>;             // DLookup
  count(table: string, where?: string): Promise<number>;                              // DCount
  sum(field: string, table: string, where?: string): Promise<number>;                 // DSum (также avg/min/max)
  transaction<T>(fn: (tx: Database) => Promise<T>): Promise<T>;                       // BeginTrans/CommitTrans
  createTableDef(def: TableDefSpec): Promise<TableDef>; createQueryDef(name: string, sql: string): Promise<QueryDef>;
  links: LinkedSource[]; close(): Promise<void>;
}
interface Recordset {
  fields: Record<string, Field>; eof: boolean; bof: boolean; recordCount: number; absolutePosition: number; bookmark: unknown;
  moveFirst(): Promise<void>; moveLast(): Promise<void>; moveNext(): Promise<void>; movePrevious(): Promise<void>; move(n: number): Promise<void>;
  findFirst(criteria: string): Promise<boolean>; findNext(criteria: string): Promise<boolean>; seek(index: string, ...values: unknown[]): Promise<boolean>;
  edit(): void; addNew(): void; update(): Promise<void>; cancelUpdate(): void; delete(): Promise<void>;
  requery(): Promise<void>; filter: string; sort: string; clone(): Recordset; close(): Promise<void>;
  [Symbol.asyncIterator](): AsyncIterator<Record<string, unknown>>;                 // for await (const row of rs)
}
interface Field { name: string; type: string; value: unknown; originalValue: unknown; size: number; required: boolean; }
interface Form {
  name: string; controls: Record<string, Control>; recordset: Recordset; recordSource: string; filter: string; filterOn: boolean; orderBy: string;
  dirty: boolean; newRecord: boolean; currentRecord: number; caption: string; visible: boolean; view: 'form'|'datasheet'|'layout'|'design';
  requery(): Promise<void>; refresh(): Promise<void>; recalc(): void; undo(): void; save(): Promise<void>; close(save?: boolean): Promise<void>;
  gotoRecord(where: 'first'|'last'|'next'|'previous'|'new' | number): Promise<void>; setFocus(): void;
  on(event: FormEvent, h: (e: FormEventArgs) => void | Promise<void>): Disposable;   // 'open'|'load'|'current'|'beforeUpdate'|'afterUpdate'|'delete'|'close'|...
  parent: Form | null; subforms: Record<string, Form>; openArgs: unknown;
}
interface Control {
  name: string; type: string; value: unknown; text: string; visible: boolean; enabled: boolean; locked: boolean;
  controlSource: string; rowSource: string; format: string; backColor: string; foreColor: string; fontWeight: string;
  left: number; top: number; width: number; height: number; tag: string; itemsSelected: unknown[]; listCount: number;
  setFocus(): void; requery(): Promise<void>; undo(): void;
  on(event: ControlEvent, h: (e: ControlEventArgs) => void | Promise<void>): Disposable;  // 'click'|'dblClick'|'change'|'beforeUpdate'|'afterUpdate'|'enter'|'exit'|'gotFocus'|'lostFocus'|'keyDown'|'notInList'|...
}
interface Report { name: string; recordSource: string; filter: string; orderBy: string; controls: Record<string, Control>; page: number; pages: number;
  on(event: 'open'|'format'|'print'|'noData'|'page'|'close', h: (e: { band: string; cancel: boolean }) => void): Disposable;
  print(opts?: { copies?: number; printer?: string }): Promise<void>; exportPdf(path: string): Promise<void>; close(): Promise<void>; }

// 1. Пересчёт остатков по складу в транзакции / Recalculate stock in a transaction
const db = App.currentDb();
await db.transaction(async tx => {
  const rs = await tx.openRecordset('SELECT id, sku FROM products');
  for await (const p of rs) {
    const inQty  = await tx.sum('qty', 'moves', `product_id = ${p.id} AND kind = 'in'`);
    const outQty = await tx.sum('qty', 'moves', `product_id = ${p.id} AND kind = 'out'`);
    await tx.execute('UPDATE products SET stock = ? WHERE id = ?', [inQty - outQty, p.id]);
  }
});

// 2. Событие формы: запрет сохранения заказа без позиций / Form event: block saving an order without items
const frm = App.forms['Заказы'];
frm.on('beforeUpdate', async e => {
  const n = await App.currentDb().count('order_items', `order_id = ${frm.controls.txtId.value}`);
  if (n === 0) { e.cancel = true; await App.ui.message('Добавьте хотя бы одну позицию', { type: 'warning' }); frm.controls.sfItems.setFocus(); }
});

// 3. Кнопка «Не в списке»: создать клиента на лету / NotInList: create a customer on the fly
frm.controls.cboCustomer.on('notInList', async e => {
  const ok = await App.ui.message(`Клиента «${e.newData}» нет. Создать?`, { type: 'question', buttons: ['yes', 'no'] });
  if (ok === 'yes') { await App.currentDb().execute('INSERT INTO customers(name) VALUES (?)', [e.newData]); e.response = 'added'; }
  else e.response = 'continue';
});

// 4. Отчёт в PDF и письмо / Report to PDF and e-mail via Mail
const rep = await App.reports.open('Счёт', { where: `id = ${frm.controls.txtId.value}`, view: 'hidden' });
await rep.exportPdf('~/Документы/Счёт.pdf');
await Meridian.mail.compose({ to: frm.controls.txtEmail.value as string, subject: 'Счёт', attachments: ['~/Документы/Счёт.pdf'] });