@webtypen/webframez-core 0.3.101 → 0.3.102

package/dist/Datatable/Datatable.d.ts

@@ -54,6 +54,9 @@ export declare class Datatable {
     } | null;
     getInit(req: Request): Promise<any>;
     private loadColumnState;
+    /** Options may be declared inline or loaded from an authenticated host callback. */
+    getColumnDisplayOptions(req: Request, key: string): Promise<any>;
+    private resolveDisplayOptions;
     private getColumnState;
     saveColumnPreferences(req: Request, columns: unknown): Promise<any>;
     resetColumnPreferences(req: Request): Promise<any>;

package/dist/Datatable/Datatable.js

@@ -64,13 +64,13 @@ class Datatable {
                 this.getFilter(req), this.getColumnState(req), this.getOnPressLink(req),
             ]);
             out.filter = filter;
-            out.columns = Object.entries(state.visible).map(([key, column]) => (Object.assign(Object.assign({}, column), { key })));
-            out.availableColumns = Object.entries(state.all).map(([key, column]) => (Object.assign(Object.assign({}, column), { key })));
+            out.columns = Object.entries(state.visible).map(([key, column]) => (Object.assign(Object.assign({}, column), { displayOptions: typeof column.displayOptions === "function" ? true : column.displayOptions, key })));
+            out.availableColumns = Object.entries(state.all).map(([key, column]) => (Object.assign(Object.assign({}, column), { displayOptions: typeof column.displayOptions === "function" ? true : column.displayOptions, key })));
             out.columnPreferences = Boolean(state.scope) && Object.keys(state.all).length > 0;
             out.columnSelection = out.columns.map((column) => {
-                var _a, _b;
-                return (Object.assign({ key: column.key }, (((_b = (_a = state.preferences) === null || _a === void 0 ? void 0 : _a.find((entry) => entry.key === column.key)) === null || _b === void 0 ? void 0 : _b.width)
-                    ? { width: state.preferences.find((entry) => entry.key === column.key).width } : {})));
+                var _a;
+                const saved = (_a = state.preferences) === null || _a === void 0 ? void 0 : _a.find((entry) => entry.key === column.key);
+                return Object.assign(Object.assign(Object.assign({ key: column.key }, ((saved === null || saved === void 0 ? void 0 : saved.width) ? { width: saved.width } : {})), ((saved === null || saved === void 0 ? void 0 : saved.title) ? { title: saved.title } : {})), ((saved === null || saved === void 0 ? void 0 : saved.displayField) && saved.displayField === column.displayField ? { displayField: saved.displayField } : {}));
             });
             out.onPressLink = onPressLink;
             if (this.exports) {
@@ -97,7 +97,35 @@ class Datatable {
             const store = new DatatablePreferencesStore_1.DatatablePreferencesStore(config || {});
             const scope = config === false ? null : yield store.scope(req);
             const preferences = scope ? yield store.load(scope) : null;
-            return { all, visible: DatatableColumnPreferences_1.DatatableColumnPreferences.apply(all, preferences), preferences, store, scope };
+            const savedKeys = Array.isArray(preferences) ? preferences.map(entry => entry === null || entry === void 0 ? void 0 : entry.key).filter(key => Object.prototype.hasOwnProperty.call(all, key)) : [];
+            const selected = savedKeys.length ? savedKeys : Object.keys(all).filter(key => !all[key].hidden);
+            const resolved = yield this.resolveDisplayOptions(req, all, selected);
+            return { all, visible: DatatableColumnPreferences_1.DatatableColumnPreferences.apply(resolved, preferences), preferences, store, scope };
+        });
+    }
+    /** Options may be declared inline or loaded from an authenticated host callback. */
+    getColumnDisplayOptions(req, key) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const all = (_a = yield this.getColumns(req)) !== null && _a !== void 0 ? _a : {};
+            if (typeof key !== "string" || !Object.prototype.hasOwnProperty.call(all, key)) {
+                throw Object.assign(new Error("Unbekannte Spalte."), { status: 400 });
+            }
+            const resolved = yield this.resolveDisplayOptions(req, all, [key]);
+            return resolved[key].displayOptions || [];
+        });
+    }
+    resolveDisplayOptions(req, columns, keys) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resolved = Object.assign({}, columns);
+            yield Promise.all(Array.from(new Set(keys)).filter(key => typeof key === "string" && Object.prototype.hasOwnProperty.call(columns, key)).map((key) => __awaiter(this, void 0, void 0, function* () {
+                const column = columns[key];
+                if (typeof column.displayOptions === "function") {
+                    const options = yield column.displayOptions(req, key);
+                    resolved[key] = Object.assign(Object.assign({}, column), { displayOptions: Array.isArray(options) ? options : [] });
+                }
+            })));
+            return resolved;
         });
     }
     getColumnState(req) {
@@ -115,7 +143,8 @@ class Datatable {
                 throw Object.assign(new Error("Spalteneinstellungen sind für diesen Benutzer nicht verfügbar."), { status: 403 });
             let preferences;
             try {
-                preferences = DatatableColumnPreferences_1.DatatableColumnPreferences.validate(columns, state.all);
+                const resolved = yield this.resolveDisplayOptions(req, state.all, Array.isArray(columns) ? columns.map(entry => entry === null || entry === void 0 ? void 0 : entry.key) : []);
+                preferences = DatatableColumnPreferences_1.DatatableColumnPreferences.validate(columns, resolved);
             }
             catch (error) {
                 throw Object.assign(error, { status: 400 });

package/dist/Datatable/DatatableColumnPreferences.d.ts

@@ -10,6 +10,15 @@ export interface DatatableColumnPreference {
     key: string;
     /** Omit to retain the current backend default. */
     width?: DatatableColumnWidth;
+    title?: string;
+    displayField?: string;
+}
+export interface DatatableDisplayOption {
+    value: string;
+    label: string;
+    type?: string;
+    plain?: boolean;
+    options?: any[];
 }
 export interface DatatableColumnPreferencesConfig {
     collection?: string;
@@ -26,5 +35,6 @@ export interface DatatableColumnContext {
 }
 export declare class DatatableColumnPreferences {
     static validate(value: unknown, columns: Record<string, any>): DatatableColumnPreference[];
+    static display(definition: any, selected?: string): any;
     static apply(columns: Record<string, any>, preferences: unknown): Record<string, any>;
 }

package/dist/Datatable/DatatableColumnPreferences.js

@@ -13,6 +13,19 @@ class DatatableColumnPreferences {
             }
             seen.add(entry.key);
             const preference = { key: entry.key };
+            if (entry.title !== undefined) {
+                if (typeof entry.title !== "string" || entry.title.length > 160)
+                    throw new Error("Ungültiger Spaltentitel (maximal 160 Zeichen).");
+                if (entry.title.trim())
+                    preference.title = entry.title.trim();
+            }
+            if (entry.displayField !== undefined && entry.displayField !== "") {
+                if (typeof entry.displayField !== "string" || !Array.isArray(columns[entry.key].displayOptions)
+                    || !columns[entry.key].displayOptions.some((option) => option.value === entry.displayField)) {
+                    throw new Error("Unzulässiges Anzeigefeld für diese Spalte.");
+                }
+                preference.displayField = entry.displayField;
+            }
             if (entry.width !== undefined) {
                 const width = entry.width;
                 if ((width === null || width === void 0 ? void 0 : width.mode) === "auto") {
@@ -29,11 +42,28 @@ class DatatableColumnPreferences {
             return preference;
         });
     }
+    static display(definition, selected) {
+        const column = Object.assign({}, definition);
+        const options = Array.isArray(column.displayOptions) ? column.displayOptions : [];
+        const option = options.find(entry => entry.value === (selected || column.displayField)) || options[0];
+        if (option) {
+            column.displayField = option.value;
+            for (const key of ["type", "plain", "options"])
+                if (option[key] !== undefined)
+                    column[key] = option[key];
+        }
+        return column;
+    }
     static apply(columns, preferences) {
-        const defaults = () => Object.fromEntries(Object.entries(columns).filter(([, column]) => column.hidden !== true));
+        const defaults = () => Object.fromEntries(Object.entries(columns).filter(([, column]) => column.hidden !== true).map(([key, column]) => [key, this.display(column)]));
         if (!Array.isArray(preferences))
             return defaults();
-        const available = preferences.filter(entry => entry && typeof entry.key === "string" && Object.prototype.hasOwnProperty.call(columns, entry.key));
+        const available = preferences.filter(entry => entry && typeof entry.key === "string" && Object.prototype.hasOwnProperty.call(columns, entry.key)).map(entry => {
+            const options = columns[entry.key].displayOptions;
+            // Removed target fields fall back independently; retain the rest of the layout.
+            return entry.displayField && (!Array.isArray(options) || !options.some((option) => option.value === entry.displayField))
+                ? Object.assign(Object.assign({}, entry), { displayField: undefined }) : entry;
+        });
         if (!available.length)
             return defaults();
         let validated;
@@ -44,7 +74,11 @@ class DatatableColumnPreferences {
             return defaults();
         }
         return Object.fromEntries(validated.map(preference => {
-            const column = Object.assign({}, columns[preference.key]);
+            const column = this.display(columns[preference.key], preference.displayField);
+            if (preference.title) {
+                column.title = preference.title;
+                column.label = preference.title;
+            }
             if (preference.width) {
                 delete column.width;
                 delete column.minWidth;

package/dist/Datatable/DatatableController.js

@@ -40,11 +40,13 @@ class DatatableController extends Controller_1.Controller {
             if (req.body.init_request || req.body.mode === "columns-get") {
                 return res.send({ status: "success", data: yield table.getInit(req) });
             }
-            if (req.body.mode === "columns-save" || req.body.mode === "columns-reset") {
+            if (["columns-save", "columns-reset", "columns-options"].includes(req.body.mode)) {
                 try {
-                    const data = req.body.mode === "columns-save"
-                        ? yield table.saveColumnPreferences(req, req.body.columns)
-                        : yield table.resetColumnPreferences(req);
+                    const data = req.body.mode === "columns-options"
+                        ? yield table.getColumnDisplayOptions(req, req.body.column)
+                        : req.body.mode === "columns-save"
+                            ? yield table.saveColumnPreferences(req, req.body.columns)
+                            : yield table.resetColumnPreferences(req);
                     return res.send({ status: "success", data });
                 }
                 catch (error) {

package/dist/Datatable/DatatableSchemaColumns.d.ts

@@ -0,0 +1,8 @@
+/** Converts DataBuilder/DataSchema field definitions into an extensible column catalog. */
+export declare class DatatableSchemaColumns {
+    static fromSchema(schema: Record<string, any>, options?: {
+        prefix?: string;
+        labelPrefix?: string;
+        prepare?: (column: Record<string, any>, field: any, path: string) => Record<string, any> | null;
+    }): Record<string, any>;
+}

package/dist/Datatable/DatatableSchemaColumns.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatatableSchemaColumns = void 0;
+/** Converts DataBuilder/DataSchema field definitions into an extensible column catalog. */
+class DatatableSchemaColumns {
+    static fromSchema(schema, options = {}) {
+        const columns = {};
+        for (const [key, field] of Object.entries(schema || {})) {
+            if (!field || /[.$]/.test(key) || ["__proto__", "constructor", "prototype"].includes(key)
+                || field.secret || field.writeOnly || field.type === "password")
+                continue;
+            const mapping = options.prefix ? `${options.prefix}.${key}` : key;
+            const label = [options.labelPrefix, field.label || key].filter(Boolean).join(" · ");
+            if (field.type === "object") {
+                Object.assign(columns, this.fromSchema(field.schema, Object.assign(Object.assign({}, options), { prefix: mapping, labelPrefix: label })));
+                continue;
+            }
+            const types = { integer: "number", float: "number", number: "number", boolean: "boolean", date: "date", datetime: "datetime", option: "option", currency_cent: "currency", currency: "currency" };
+            const column = Object.assign(Object.assign({ label, mapping, type: types[field.type] || "string", width: 170, hidden: true, sortable: !["array", "file", "filemanager_file", "relation"].includes(field.type) && !field.multi }, (field.type === "currency" ? { plain: true } : {})), (field.options ? { options: field.options } : {}));
+            const prepared = options.prepare ? options.prepare(column, field, mapping) : column;
+            if (prepared)
+                columns[mapping] = prepared;
+        }
+        return columns;
+    }
+}
+exports.DatatableSchemaColumns = DatatableSchemaColumns;

package/dist/index.d.ts

@@ -29,6 +29,7 @@ export * from "./DataBuilder/DataBuilder";
 export * from "./DataBuilder/DataBuilderController";
 export * from "./Datatable/Datatable";
 export * from "./Datatable/DatatableColumnPreferences";
+export * from "./Datatable/DatatableSchemaColumns";
 export * from "./Datatable/DatatablePreferencesStore";
 export * from "./Datatable/DatatableRegistry";
 export * from "./Datatable/DatatableController";

package/dist/index.js

@@ -46,6 +46,7 @@ __exportStar(require("./DataBuilder/DataBuilder"), exports);
 __exportStar(require("./DataBuilder/DataBuilderController"), exports);
 __exportStar(require("./Datatable/Datatable"), exports);
 __exportStar(require("./Datatable/DatatableColumnPreferences"), exports);
+__exportStar(require("./Datatable/DatatableSchemaColumns"), exports);
 __exportStar(require("./Datatable/DatatablePreferencesStore"), exports);
 __exportStar(require("./Datatable/DatatableRegistry"), exports);
 __exportStar(require("./Datatable/DatatableController"), exports);

package/docs/datatables.md

@@ -101,3 +101,28 @@ mappings, active filter/search/sort fields and sums, as well as model-selector
 preview fields. This avoids breaking a sort/filter on a hidden column. Dependencies
 inside custom expressions, custom filters, exports or other calculated columns
 remain the table author's responsibility.
+
+## Relation display fields and custom titles
+
+A column can declare `displayOptions: [{ value: "name", label: "Name", type: "string" }]`
+or an async `displayOptions(req, columnKey)` callback. The callback receives the
+normal authenticated request. Initialization advertises lazy options with `true`;
+`mode: "columns-options", column: "key"` resolves them when the editor needs them.
+Only visible columns resolve options during normal loading. `displayField` selects
+the backend default; otherwise the first option is used.
+
+Saved preferences accept `title` (up to 160 characters) and `displayField` in
+addition to width. Empty values restore the backend defaults. An unknown display
+field is rejected on save; if a previously saved field disappears, loading falls
+back to the default while preserving the other layout settings.
+
+Core validates the selection and exposes it through `context.columns[key].displayField`;
+the host performs the relation lookup and writes the value to the column's stable
+`mapping`. Options can supply `type`, `plain` and `options` for typed rendering.
+Never interpret an unchecked client field as a database projection.
+
+`DatatableSchemaColumns.fromSchema(schema, { prefix, labelPrefix, prepare })`
+creates an optional column catalog from nested DataBuilder/DataSchema fields.
+The `prepare(column, field, path)` callback can attach inline or lazy display
+options, change the mapping, or return null to omit a field. Plugin installation,
+tenant checks and relation hydration belong in the host adapter.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@webtypen/webframez-core",
-    "version": "0.3.101",
+    "version": "0.3.102",
     "description": "The core package of the typescript based webframez (web-framework) by webtypen.de",
     "homepage": "https://webtypen.de/",
     "license": "MIT",