shutro-erp 0.3.4 → 0.3.6

package/dist/recruitment/module.js

@@ -0,0 +1,194 @@
+/**
+ * The data layer of Hiring (RFC 0021): openings for Workforce positions with their headcount, applicants moving
+ * through stages, and interviewers' scorecards — each interviewer sees only their own, so no opinion steers the next;
+ * the applicant's average rating shows to everyone. One email applies once per opening. Expected salaries are for
+ * hiring managers only.
+ */
+import { hrShutro } from '../hr/index.js';
+import { orm } from '../server/orm.js';
+import { check, compute, defineModel, defineModule, f, record, } from './.kosh/bindings.js';
+const READ = ['read'];
+const ALL = ['read', 'write', 'create', 'unlink'];
+const me = { $env: 'uid' };
+export const HiringStage = defineModel('hiring.stage', {
+    label: 'Hiring stage',
+    archivable: true,
+    recName: 'name',
+    order: ['sequence asc', 'id asc'],
+    access: { 'hiring.user': READ, 'hiring.manager': ALL },
+    fields: {
+        name: f.char({ required: true, translate: true }),
+        sequence: f.integer({ required: true, default: 10 }),
+        fold: f.boolean({ default: false, label: 'Folded on the board' }),
+        /** Applicants here were hired: the stage the hire step moves them to. */
+        hired: f.boolean({ default: false }),
+    },
+});
+export const HiringOpening = defineModel('hiring.opening', {
+    label: 'Opening',
+    recName: 'name',
+    order: ['state asc', 'name asc'],
+    companyScoped: { required: true },
+    tracking: ['state', 'headcount', 'manager'],
+    access: { 'hiring.user': READ, 'hiring.manager': ALL },
+    fields: {
+        name: f.char({ required: true, label: 'Opening' }),
+        job: f.many2one('hr.job', { ondelete: 'set null', label: 'Position' }),
+        department: f.many2one('hr.department', { ondelete: 'set null' }),
+        manager: f.many2one('res.users', {
+            default: (env) => env.userId,
+            label: 'Hiring manager',
+        }),
+        headcount: f.integer({ required: true, default: 1, label: 'To hire' }),
+        hiredCount: f.integer({
+            store: true,
+            label: 'Hired',
+            ...compute('hiring.opening', 'hiredCount', ['applicants.employee'], (openings) => {
+                for (const o of openings)
+                    o.hiredCount = o.applicants.filter((a) => a.employee !== null).length;
+            }),
+        }),
+        applicants: f.one2many('hiring.applicant', 'opening'),
+        description: f.text(),
+        state: f.state({
+            states: { open: 'Open', closed: 'Closed' },
+            initial: 'open',
+            transitions: {
+                close: { from: ['open'], to: 'closed' },
+                reopen: { from: ['closed'], to: 'open' },
+            },
+        }),
+    },
+    sqlConstraints: {
+        headcountPositive: {
+            check: orm.sql `headcount > 0`,
+            message: 'An opening hires at least one person.',
+        },
+    },
+});
+export const HiringApplicant = defineModel('hiring.applicant', {
+    label: 'Applicant',
+    recName: 'name',
+    order: ['id desc'],
+    companyScoped: { required: true },
+    tracking: ['stage', 'refused', 'employee'],
+    access: {
+        'hiring.user': ['read', 'write', 'create'],
+        'hiring.manager': [...ALL, 'export', 'import'],
+    },
+    fields: {
+        name: f.char({ required: true, label: 'Candidate' }),
+        email: f.char({ required: true }),
+        phone: f.char(),
+        opening: f.many2one('hiring.opening', { required: true, ondelete: 'cascade' }),
+        stage: f.many2one('hiring.stage', { ondelete: 'restrict' }),
+        source: f.selection({
+            website: 'Website',
+            referral: 'Referral',
+            job_board: 'Job board',
+            linkedin: 'LinkedIn',
+            agency: 'Agency',
+            other: 'Other',
+        }, {}),
+        expectedSalary: f.decimal({ scale: 2, label: 'Expected salary', groups: ['hiring.manager'] }),
+        refused: f.boolean({ default: false }),
+        refuseReason: f.char({ label: 'Refused because' }),
+        scorecards: f.one2many('hiring.scorecard', 'applicant'),
+        /** The average score of the scorecards, out of 5 (null before the first). */
+        rating: f.decimal({
+            scale: 1,
+            store: true,
+            label: 'Rating',
+            ...compute('hiring.applicant', 'rating', ['scorecards.score'], (applicants) => {
+                for (const a of applicants) {
+                    const scores = [...a.scorecards].map((s) => s.score);
+                    a.rating =
+                        scores.length === 0
+                            ? null
+                            : orm
+                                .toDecimal(scores.reduce((x, y) => x + y, 0))
+                                .div(scores.length)
+                                .toDecimalPlaces(1);
+                }
+            }),
+        }),
+        /** The Workforce employee once hired: set only by the hire step (see `hiredByTheHireStep`). */
+        employee: f.many2one('hr.employee', { ondelete: 'set null' }),
+        status: f.selection({ active: 'In progress', hired: 'Hired', refused: 'Refused' }, {
+            store: true,
+            ...compute('hiring.applicant', 'status', ['employee', 'refused'], (applicants) => {
+                for (const a of applicants)
+                    a.status = a.employee !== null ? 'hired' : a.refused ? 'refused' : 'active';
+            }),
+        }),
+        notes: f.text(),
+    },
+    constraints: {
+        // One email applies once per opening (applications of another opening are separate).
+        oneApplication: {
+            ...check('hiring.applicant', ['email', 'opening'], async (applicants) => applicants.env.asSuperuser({ reason: 'duplicate applications' }, async (su) => {
+                const failing = [];
+                for (const a of applicants) {
+                    const twins = await su.model('hiring.applicant').search({
+                        where: { opening: a.opening.id, email: { ilike: a.email.trim() }, id: { ne: a.id } },
+                        limit: 1,
+                    });
+                    if (twins.length > 0)
+                        failing.push(a.id);
+                }
+                return failing;
+            })),
+            message: 'This person already applied to this opening.',
+        },
+        // Hired only through `POST /api/v1/hiring/applicants/:id/hire`, which runs in an audited superuser scope.
+        hiredByTheHireStep: {
+            ...check('hiring.applicant', ['employee'], async (applicants) => applicants.env.su
+                ? []
+                : [...applicants].filter((a) => a.employee !== null).map((a) => a.id)),
+            message: 'Applicants are hired with Hire, which makes their employee.',
+        },
+        refusedWithReason: {
+            ...check('hiring.applicant', ['refused', 'refuseReason'], async (applicants) => [...applicants]
+                .filter((a) => a.refused && (a.refuseReason ?? '').trim() === '')
+                .map((a) => a.id)),
+            message: 'A refused applicant says why.',
+        },
+    },
+});
+export const HiringScorecard = defineModel('hiring.scorecard', {
+    label: 'Scorecard',
+    order: ['id desc'],
+    access: { 'hiring.user': ALL, 'hiring.manager': ALL },
+    rules: {
+        // Independent opinions: an interviewer sees and changes only their own.
+        own: { groups: ['hiring.user'], perms: [...ALL], domain: { interviewer: me } },
+        all: { groups: ['hiring.manager'], perms: [...ALL], domain: {} },
+    },
+    fields: {
+        applicant: f.many2one('hiring.applicant', { required: true, ondelete: 'cascade' }),
+        interviewer: f.many2one('res.users', { required: true, default: (env) => env.userId }),
+        score: f.integer({ required: true, default: 3, label: 'Score (1–5)' }),
+        recommendation: f.selection({ strong_yes: 'Strong yes', yes: 'Yes', no: 'No', strong_no: 'Strong no' }, { required: true, default: 'yes' }),
+        notes: f.text(),
+    },
+    sqlConstraints: {
+        scoreRange: { check: orm.sql `score BETWEEN 1 AND 5`, message: 'A score is from 1 to 5.' },
+    },
+});
+export const recruitmentShutro = defineModule({
+    name: 'recruitment',
+    version: '0.2.0',
+    depends: [hrShutro],
+    groups: [
+        orm.defineGroup({ code: 'hiring.user', label: 'Interviewer', implies: ['hr.user'] }),
+        orm.defineGroup({ code: 'hiring.manager', label: 'Hiring manager', implies: ['hiring.user'] }),
+    ],
+    models: [HiringStage, HiringOpening, HiringApplicant, HiringScorecard],
+    data: [
+        record('hiring.stage', 'stage_new', { name: 'New', sequence: 1 }, { noupdate: true }),
+        record('hiring.stage', 'stage_screening', { name: 'Screening', sequence: 2 }, { noupdate: true }),
+        record('hiring.stage', 'stage_interview', { name: 'Interview', sequence: 3 }, { noupdate: true }),
+        record('hiring.stage', 'stage_offer', { name: 'Offer', sequence: 4 }, { noupdate: true }),
+        record('hiring.stage', 'stage_hired', { name: 'Hired', sequence: 5, hired: true, fold: true }, { noupdate: true }),
+    ],
+});

package/dist/recruitment/web/HireButton.d.ts

@@ -0,0 +1,9 @@
+/**
+ * "Hire" on an applicant in progress (a node component of the applicant form): a confirmation that names what
+ * happens — the Workforce employee is made from the applicant, the applicant moves to the hired stage, and the
+ * opening closes when its headcount is reached — through `POST /api/v1/hiring/applicants/:id/hire`; the form
+ * reloads afterwards. Shown to hiring managers (the expected salary, theirs only, is the hint); the server decides.
+ */
+import { type NodeComponentProps } from '../../ui/index.js';
+import { type ReactElement } from 'react';
+export declare function HireButton({ api, record, model, served, reload, }: NodeComponentProps): ReactElement | null;

package/dist/recruitment/web/HireButton.js

@@ -0,0 +1,32 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * "Hire" on an applicant in progress (a node component of the applicant form): a confirmation that names what
+ * happens — the Workforce employee is made from the applicant, the applicant moves to the hired stage, and the
+ * opening closes when its headcount is reached — through `POST /api/v1/hiring/applicants/:id/hire`; the form
+ * reloads afterwards. Shown to hiring managers (the expected salary, theirs only, is the hint); the server decides.
+ */
+import { Alert, Button, Dialog } from '../../ui/index.js';
+import { useMutation } from '@tanstack/react-query';
+import { useState } from 'react';
+import { useTranslation } from 'react-i18next';
+export function HireButton({ api, record, model, served, reload, }) {
+    const { t } = useTranslation('recruitment');
+    const [open, setOpen] = useState(false);
+    const [error, setError] = useState(null);
+    const hire = useMutation({
+        mutationFn: () => api.call('POST', `/api/v1/hiring/applicants/${String(record?.id)}/hire`, {}),
+        onSuccess: () => {
+            setOpen(false);
+            setError(null);
+            reload();
+        },
+        onError: (e) => setError(e.message),
+    });
+    if (record === null || typeof record.id !== 'number')
+        return null;
+    if (record['status'] !== 'active')
+        return null;
+    if (served.fields[model]?.['expectedSalary'] === undefined)
+        return null;
+    return (_jsxs(_Fragment, { children: [_jsx(Button, { variant: "primary", onClick: () => setOpen(true), children: t('hire.button') }), _jsx(Dialog, { open: open, onOpenChange: setOpen, title: t('hire.title', { name: String(record['name'] ?? '') }), footer: _jsx(Button, { variant: "primary", busy: hire.isPending, onClick: () => hire.mutate(), children: t('hire.confirm') }), children: _jsxs("div", { className: "grid gap-3", children: [error === null ? null : _jsx(Alert, { tone: "danger", children: error }), _jsx("p", { className: "text-sm", children: t('hire.explain') })] }) })] }));
+}

package/dist/recruitment/web/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @packageDocumentation
+ * The web contribution of `shutro-erp/recruitment`: the "Hire" button on applicants.
+ */
+import { type Registry } from '../../ui/index.js';
+import type { i18n } from 'i18next';
+import { messages } from './messages.js';
+export { HireButton } from './HireButton.js';
+/** Registers the component (and the messages in `i18n`, when given). */
+export declare function registerRecruitmentWeb(registry: Registry, i18n?: i18n): Registry;
+export { messages as recruitmentMessages };

package/dist/recruitment/web/index.js

@@ -0,0 +1,16 @@
+/**
+ * @packageDocumentation
+ * The web contribution of `shutro-erp/recruitment`: the "Hire" button on applicants.
+ */
+import { addMessages } from '../../ui/index.js';
+import { HireButton } from './HireButton.js';
+import { messages } from './messages.js';
+export { HireButton } from './HireButton.js';
+/** Registers the component (and the messages in `i18n`, when given). */
+export function registerRecruitmentWeb(registry, i18n) {
+    registry.registerComponent('hiring.Hire', HireButton);
+    if (i18n !== undefined)
+        addMessages(i18n, 'recruitment', messages);
+    return registry;
+}
+export { messages as recruitmentMessages };

package/dist/recruitment/web/messages.d.ts

@@ -0,0 +1,2 @@
+/** Messages of the Hiring screens (namespace `recruitment`), in English and Bangla. */
+export declare const messages: Readonly<Record<string, object>>;

package/dist/recruitment/web/messages.js

@@ -0,0 +1,19 @@
+/** Messages of the Hiring screens (namespace `recruitment`), in English and Bangla. */
+export const messages = {
+    en: {
+        hire: {
+            button: 'Hire',
+            title: 'Hire {{name}}',
+            explain: 'They become an employee in Workforce with the opening’s position and department, move to the hired stage, and the opening closes when everyone it was for is hired.',
+            confirm: 'Hire',
+        },
+    },
+    bn: {
+        hire: {
+            button: 'নিয়োগ দিন',
+            title: '{{name}}-কে নিয়োগ দিন',
+            explain: 'তিনি পদ ও বিভাগসহ ওয়ার্কফোর্সে কর্মী হবেন, নিয়োগপ্রাপ্ত ধাপে যাবেন, এবং যত জনের জন্য পদটি ছিল সবাই নিয়োগ পেলে পদটি বন্ধ হবে।',
+            confirm: 'নিয়োগ দিন',
+        },
+    },
+};

package/dist/reporting/documents.d.ts

@@ -34,6 +34,11 @@ export interface DocumentData {
     readonly locale?: string;
     readonly tz?: string;
 }
+/**
+ * A QR code as SVG (one path of dark modules, a quiet zone of 4), from `qrcode`'s synchronous matrix — rendering
+ * stays synchronous. Medium error correction: a printed ticket survives a crease.
+ */
+export declare function qrSvg(content: string): string;
 /** The HTML of a document (a complete page, also used for the designer's preview). */
 export declare function renderHtml(layout: Layout, data: DocumentData, fields: DocumentFields, format: DocumentFormat, options?: {
     readonly dir?: 'ltr' | 'rtl';

package/dist/reporting/documents.js

@@ -4,6 +4,7 @@
  * as the caller (rules and field security), values are formatted for the document's language, and every render is
  * audited. Modules ship default templates in their manifests; administrators edit copies as data.
  */
+import QRCode from 'qrcode';
 import { amountInWords } from './words.js';
 const esc = (text) => String(text ?? '').replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[c]);
 /** Formats a value for print: Money, decimals, dates, booleans, related records (their display name). */
@@ -124,6 +125,22 @@ function text(data, fields, template) {
         return esc(formatValue(r.value, r.kind, { locale: data.locale ?? 'en-US', tz: data.tz ?? 'UTC' }));
     });
 }
+/**
+ * A QR code as SVG (one path of dark modules, a quiet zone of 4), from `qrcode`'s synchronous matrix — rendering
+ * stays synchronous. Medium error correction: a printed ticket survives a crease.
+ */
+export function qrSvg(content) {
+    const { modules } = QRCode.create(content, { errorCorrectionLevel: 'M' });
+    const size = modules.size;
+    const quiet = 4;
+    let d = '';
+    for (let y = 0; y < size; y += 1)
+        for (let x = 0; x < size; x += 1)
+            if (modules.get(y, x))
+                d += `M${x + quiet} ${y + quiet}h1v1h-1z`;
+    const box = size + quiet * 2;
+    return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${box} ${box}" shape-rendering="crispEdges" role="img" aria-label="QR code"><rect width="${box}" height="${box}" fill="#fff"/><path d="${d}" fill="#000"/></svg>`;
+}
 function blockHtml(block, data, fields, format) {
     switch (block.kind) {
         case 'heading': {
@@ -176,6 +193,14 @@ function blockHtml(block, data, fields, format) {
             return '<hr>';
         case 'pageBreak':
             return '<div class="page-break"></div>';
+        case 'qr': {
+            const value = resolve(data, fields, block.bind).value;
+            const content = value === null || value === undefined ? '' : String(value);
+            if (content === '')
+                return '';
+            const label = block.label === undefined ? '' : `<div class="qr-label">${esc(block.label)}</div>`;
+            return `<div class="qr" style="width:${block.size ?? 32}mm">${qrSvg(content)}${label}</div>`;
+        }
         case 'signature':
             return `<div class="signatures">${block.labels.map((l) => `<div class="signature"><div class="line"></div><div>${esc(l)}</div></div>`).join('')}</div>`;
         case 'columns':
@@ -202,6 +227,8 @@ hr { border: 0; border-top: 1px solid #ccc; margin: 5mm 0; }
 .columns { display: grid; grid-template-columns: 1fr 1fr; gap: 10mm; }
 .signatures { display: grid; grid-auto-flow: column; gap: 12mm; margin-top: 18mm; text-align: center; font-size: 9.5pt; }
 .signature .line { border-top: 1px solid #111; margin-bottom: 2mm; }
+.qr { margin: 2mm 0; } .qr svg { width: 100%; height: auto; display: block; }
+.qr-label { font-size: 8.5pt; color: #555; text-align: center; margin-top: 1mm; }
 tr, .field { break-inside: avoid; }
 `;
 /** The HTML of a document (a complete page, also used for the designer's preview). */
@@ -250,7 +277,7 @@ export async function loadDocumentData(env, model, ids, layout, fields) {
     const paths = new Set();
     const collect = (blocks, prefix = '') => {
         for (const b of blocks) {
-            if (b.kind === 'field')
+            if (b.kind === 'field' || b.kind === 'qr')
                 paths.add(prefix + b.bind);
             else if (b.kind === 'fields')
                 for (const i of b.items)

package/dist/reporting/index.d.ts

@@ -8,7 +8,7 @@
 import { defineModule } from '../modules-sdk/index.js';
 import { reportingShutro } from './models.js';
 import type { ScheduleEngine } from './schedules.js';
-export { type Block, closeDocuments, type DocumentData, type DocumentFields, type DocumentFormat, formatValue as formatDocumentValue, type Layout, loadDocumentData, renderHtml, renderPdf, } from './documents.js';
+export { type Block, closeDocuments, type DocumentData, type DocumentFields, type DocumentFormat, formatValue as formatDocumentValue, type Layout, loadDocumentData, qrSvg, renderHtml, renderPdf, } from './documents.js';
 export { type Amount, type Condition, type FieldInfo, type Header, type Measure, nextBucket, ReportError, type ReportQuery, type ReportResult, runReport, type Value, zonedStart, } from './pivot.js';
 export { parseReportQuery, registerReportRoutes, reportTable } from './routes.js';
 export { documentFields, installTemplates, layoutProblems, registerDocumentRoutes, renderDocument, scheduleRenderer, } from './routes-documents.js';

package/dist/reporting/index.js

@@ -10,9 +10,10 @@ import { base } from '../server/index.js';
 import { dashboard, form, list, spreadsheet } from '../views/index.js';
 import { closeDocuments } from './documents.js';
 import { reportingShutro } from './models.js';
+import { installOverviews, registerOverviewRoutes } from './overviews.js';
 import { registerReportRoutes } from './routes.js';
 import { installTemplates, registerDocumentRoutes } from './routes-documents.js';
-export { closeDocuments, formatValue as formatDocumentValue, loadDocumentData, renderHtml, renderPdf, } from './documents.js';
+export { closeDocuments, formatValue as formatDocumentValue, loadDocumentData, qrSvg, renderHtml, renderPdf, } from './documents.js';
 export { nextBucket, ReportError, runReport, zonedStart, } from './pivot.js';
 export { parseReportQuery, registerReportRoutes, reportTable } from './routes.js';
 export { documentFields, installTemplates, layoutProblems, registerDocumentRoutes, renderDocument, scheduleRenderer, } from './routes-documents.js';
@@ -127,10 +128,11 @@ export const reporting = defineModule({
         },
     },
     hooks: {
-        defaults: async (env, modules) => `${await installTemplates(env, modules)} document template(s) installed`,
+        defaults: async (env, modules) => `${await installTemplates(env, modules)} document template(s), ${await installOverviews(env, modules)} overview(s) installed`,
     },
     routes: (context) => {
         registerReportRoutes(context);
+        registerOverviewRoutes(context);
         const engine = registerDocumentRoutes(context);
         engines.set(context.app, engine);
         if (process.env['KOSH_SCHEDULES'] !== 'off')

package/dist/reporting/models.js

@@ -27,6 +27,15 @@ const Dashboard = defineModel('report.dashboard', {
         name: f.char({ required: true }),
         items: f.json({ required: true, default: [] }),
         shared: f.boolean({ default: false }),
+        /** The module whose overview this is (RFC 0022 §3.2); empty for a user's own dashboard. */
+        key: f.char({ size: 100 }),
+    },
+    sqlConstraints: {
+        oneOverview: {
+            unique: ['key'],
+            where: orm.sql `key IS NOT NULL`,
+            message: 'An app has one overview.',
+        },
     },
 });
 /** A spreadsheet: cells by reference (`{ A1: '12', B1: '=SUM(A1:A3)', C1: '=REPORT("sale.order", "sum:amount")' }`). */

package/dist/reporting/overviews.d.ts

@@ -0,0 +1,16 @@
+/**
+ * App overviews (RFC 0022 §3.2): the cards an app declares in its manifest become a shared dashboard keyed by the
+ * module, installed once (`hooks.defaults`, idempotent: a dashboard a user has since changed is left alone), and
+ * opened by the app's generated *Overview* menu through `GET /api/v1/reports/overview?app=`.
+ */
+import type { KoshModule } from '../modules-sdk/index.js';
+import { type ModuleContext } from '../server/index.js';
+import type { Env } from '../server/orm.js';
+/** Installs the overview dashboards the served modules declare and do not have yet; returns how many. */
+export declare function installOverviews(env: Env, modules: readonly KoshModule[]): Promise<number>;
+/**
+ * `GET /api/v1/reports/overview?app=sales`: the app's overview — its label and cards — for the Overview page. Read
+ * as the system (the dashboard itself needs the reports' access; the cards then query as the user), for any user
+ * who may open the app's menu.
+ */
+export declare function registerOverviewRoutes(context: ModuleContext): void;

package/dist/reporting/overviews.js

@@ -0,0 +1,56 @@
+import { HttpProblem } from '../server/index.js';
+const dashboards = (env) => env.model('report.dashboard');
+/** Installs the overview dashboards the served modules declare and do not have yet; returns how many. */
+export async function installOverviews(env, modules) {
+    let created = 0;
+    for (const m of modules) {
+        if (m.overview === undefined || m.app === undefined)
+            continue;
+        const existing = await dashboards(env).search({ where: { key: m.name }, limit: 1 });
+        if (existing.ids.length > 0)
+            continue;
+        await dashboards(env).create([
+            {
+                name: `${m.app.label} — Overview`,
+                key: m.name,
+                shared: true,
+                items: m.overview.cards.map((card) => ({ ...card })),
+            },
+        ]);
+        created += 1;
+    }
+    return created;
+}
+/**
+ * `GET /api/v1/reports/overview?app=sales`: the app's overview — its label and cards — for the Overview page. Read
+ * as the system (the dashboard itself needs the reports' access; the cards then query as the user), for any user
+ * who may open the app's menu.
+ */
+export function registerOverviewRoutes(context) {
+    const { app, registry, shutro } = context;
+    app.get('/api/v1/reports/overview', async (request) => {
+        const code = String(request.query?.app ?? '');
+        const module = registry.loaded.modules.find((m) => m.app?.code === code);
+        if (module === undefined || module.overview === undefined)
+            throw new HttpProblem(404, 'no-overview', 'No overview', `The app '${code}' has no overview.`);
+        // Signed in (the route is not public); the app's visibility is the menu's.
+        await request.env(async () => undefined);
+        const row = await shutro.bootstrap({ reason: `overview of ${code}` }, async (env) => {
+            const found = await dashboards(env).search({
+                where: { key: module.name },
+                limit: 1,
+            });
+            const [first] = (await found.load(['name', 'items'])).read(['id', 'name', 'items']);
+            return first;
+        });
+        if (row === undefined)
+            throw new HttpProblem(404, 'no-overview', 'No overview', `The overview of '${code}' is not installed yet (run the apps' defaults).`);
+        return {
+            id: row['id'],
+            name: row['name'],
+            app: code,
+            label: module.app?.label ?? code,
+            cards: row['items'],
+        };
+    });
+}

package/dist/reporting/routes-documents.js

@@ -51,7 +51,7 @@ export function layoutProblems(layout, model, fields) {
     };
     const walk = (blocks) => {
         for (const b of blocks) {
-            if (b.kind === 'field')
+            if (b.kind === 'field' || b.kind === 'qr')
                 check(b.bind, model);
             else if (b.kind === 'fields')
                 for (const i of b.items)