@genesislcap/blank-app-seed 5.22.2-prerelease.2 → 5.23.1

package/.genx/tests/fixtures/routes-full.json

@@ -0,0 +1,299 @@
+[
+  {
+    "name": "Dashboard",
+    "icon": "chart-bar",
+    "tiles": [
+      {
+        "title": "Positions",
+        "type": "entity-manager",
+        "config": {
+          "resourceName": "ALL_POSITIONS",
+          "title": "Positions",
+          "entityName": "Position",
+          "createEvent": "EVENT_POSITION_INSERT",
+          "updateEvent": "EVENT_POSITION_MODIFY",
+          "deleteEvent": "EVENT_POSITION_DELETE",
+          "enableSearchBar": true,
+          "enableFilters": true,
+          "sizeColumnsToFit": true,
+          "modalPosition": "right",
+          "permissions": {
+            "viewRight": "ViewPosition",
+            "updateRight": "TradePosition"
+          },
+          "eventing": {
+            "publishEventName": "selectedPosition"
+          },
+          "columns": [
+            {
+              "field": "INSTRUMENT_ID",
+              "headerName": "Instrument",
+              "type": "string"
+            },
+            {
+              "field": "VALUE",
+              "headerName": "Value",
+              "type": "number"
+            },
+            {
+              "field": "LAST_UPDATED",
+              "headerName": "Updated",
+              "type": "date"
+            }
+          ],
+          "createFormUiSchema": {
+            "type": "VerticalLayout",
+            "elements": [
+              {
+                "type": "Control",
+                "scope": "#/properties/INSTRUMENT_ID"
+              }
+            ]
+          },
+          "updateFormUiSchema": {
+            "type": "VerticalLayout",
+            "elements": [
+              {
+                "type": "Control",
+                "scope": "#/properties/INSTRUMENT_ID"
+              }
+            ]
+          },
+          "filterFormUiSchema": {
+            "type": "VerticalLayout",
+            "elements": [
+              {
+                "type": "Control",
+                "scope": "#/properties/INSTRUMENT_ID"
+              }
+            ]
+          },
+          "customEvents": [
+            {
+              "name": "EVENT_POSITION_CLOSE",
+              "baseEvent": "POSITION_CLOSE",
+              "icon": "times",
+              "tooltip": "Close Position",
+              "position": "action",
+              "confirmSubmit": {
+                "state": "enabled",
+                "message": "Are you sure?"
+              },
+              "hasForm": true,
+              "uischema": {
+                "type": "VerticalLayout",
+                "elements": [
+                  {
+                    "type": "Control",
+                    "scope": "#/properties/REASON"
+                  }
+                ]
+              }
+            }
+          ],
+          "gridOptions": {
+            "onRowClicked": {
+              "category": "fdc3",
+              "channelName": "positions",
+              "type": "position"
+            }
+          }
+        }
+      },
+      {
+        "title": "Trades",
+        "type": "grid-pro",
+        "config": {
+          "resourceName": "ALL_TRADES",
+          "permissions": {
+            "viewRight": "ViewTrade"
+          },
+          "eventing": {
+            "listener": {
+              "eventName": "selectedPosition",
+              "mappings": [
+                {
+                  "sourceField": "INSTRUMENT_ID",
+                  "targetField": "INSTRUMENT_ID"
+                }
+              ]
+            }
+          },
+          "gridOptions": {
+            "columns": [
+              {
+                "field": "TRADE_ID",
+                "headerName": "Trade ID"
+              },
+              {
+                "field": "QUANTITY",
+                "headerName": "Qty",
+                "type": "number"
+              }
+            ],
+            "rowSelection": "single"
+          }
+        }
+      },
+      {
+        "title": "P&L Chart",
+        "type": "chart",
+        "config": {
+          "resourceName": "ALL_POSITIONS",
+          "type": "line",
+          "xField": "INSTRUMENT_ID",
+          "yField": "VALUE",
+          "permissions": {
+            "viewRight": "ViewPosition"
+          }
+        }
+      },
+      {
+        "title": "Allocation",
+        "type": "chart",
+        "config": {
+          "resourceName": "ALL_POSITIONS",
+          "type": "pie",
+          "xField": "INSTRUMENT_ID",
+          "yField": "VALUE"
+        }
+      },
+      {
+        "title": "New Trade",
+        "type": "smart-form",
+        "config": {
+          "resourceName": "ALL_TRADES",
+          "createEvent": "EVENT_TRADE_INSERT",
+          "permissions": {
+            "updateRight": "TradePosition"
+          },
+          "uischema": {
+            "type": "VerticalLayout",
+            "elements": [
+              {
+                "type": "Control",
+                "scope": "#/properties/INSTRUMENT_ID"
+              },
+              {
+                "type": "Control",
+                "scope": "#/properties/QUANTITY"
+              }
+            ]
+          }
+        }
+      }
+    ]
+  },
+  {
+    "name": "Analytics",
+    "icon": "chart-pie",
+    "tiles": [
+      {
+        "title": "Historical Positions",
+        "type": "entity-manager",
+        "config": {
+          "resourceName": "HISTORICAL_POSITIONS",
+          "title": "Historical Positions",
+          "reqrep": true,
+          "snapshot": true,
+          "columns": [
+            {
+              "field": "INSTRUMENT_ID",
+              "headerName": "Instrument"
+            },
+            {
+              "field": "VALUE",
+              "headerName": "Value",
+              "type": "number"
+            }
+          ]
+        }
+      },
+      {
+        "title": "Risk Grid",
+        "type": "grid-pro",
+        "config": {
+          "resourceName": "ALL_RISK",
+          "reqrep": true,
+          "gridOptions": {
+            "columns": [
+              {
+                "field": "RISK_VALUE",
+                "headerName": "Risk"
+              }
+            ]
+          }
+        }
+      },
+      {
+        "title": "Instrument Chart",
+        "type": "chart",
+        "config": {
+          "resourceName": "ALL_INSTRUMENTS",
+          "type": "bar",
+          "xField": "INSTRUMENT_ID",
+          "yField": "QUANTITY"
+        }
+      },
+      {
+        "title": "Instrument Form",
+        "type": "smart-form",
+        "config": {
+          "resourceName": "ALL_INSTRUMENTS",
+          "createEvent": "EVENT_INSTRUMENT_INSERT",
+          "uischema": {
+            "type": "VerticalLayout",
+            "elements": [
+              {
+                "type": "Control",
+                "scope": "#/properties/INSTRUMENT_ID"
+              },
+              {
+                "type": "Control",
+                "scope": "#/properties/QUANTITY"
+              }
+            ]
+          }
+        }
+      }
+    ]
+  },
+  {
+    "name": "Settings",
+    "icon": "cog",
+    "tiles": [
+      {
+        "title": "Users",
+        "type": "entity-manager",
+        "config": {
+          "resourceName": "ALL_USERS",
+          "title": "Users",
+          "createEvent": "EVENT_USER_INSERT",
+          "updateEvent": "EVENT_USER_MODIFY",
+          "deleteEvent": "EVENT_USER_DELETE"
+        }
+      },
+      {
+        "title": "User Form",
+        "type": "smart-form",
+        "config": {
+          "resourceName": "ALL_USERS",
+          "createEvent": "EVENT_USER_INSERT",
+          "uischema": {
+            "type": "VerticalLayout",
+            "elements": [
+              {
+                "type": "Control",
+                "scope": "#/properties/USER_NAME"
+              },
+              {
+                "type": "Control",
+                "scope": "#/properties/EMAIL"
+              }
+            ]
+          }
+        }
+      }
+    ]
+  }
+]

package/.genx/tests/fixtures/testapp/client/src/pages/Home/Home.tsx

@@ -0,0 +1,12 @@
+import { EntityManagement } from '@genesislcap/foundation-entity-management/react';
+import './Home.css';
+
+const Home = () => {
+  return (
+    <section className="home-page">
+      <EntityManagement prefix="rapid" resourceName="ALL_TRADES" createEvent="EVENT_TRADE_INSERT" />
+    </section>
+  );
+};
+
+export default Home;

package/.genx/utils/formatJSONValue.js

@@ -1,6 +1,42 @@
-const formatJSONValue = (value) => {
+const toJsStringLiteral = require('./toJsStringLiteral');
+
+const IDENTIFIER_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+
+const formatTSValue = (value, indent = 0) => {
+  if (value === null) return 'null';
+  if (typeof value === 'boolean') return String(value);
+  if (typeof value === 'number') return String(value);
+  if (typeof value === 'string') return toJsStringLiteral(value);
+
+  const pad = ' '.repeat(indent + 2);
+  const closePad = ' '.repeat(indent);
+
+  if (Array.isArray(value)) {
+    if (value.length === 0) return '[]';
+    const items = value.map((v) => `${pad}${formatTSValue(v, indent + 2)}`).join(',\n');
+    return `[\n${items},\n${closePad}]`;
+  }
+
+  if (typeof value === 'object') {
+    const entries = Object.entries(value);
+    if (entries.length === 0) return '{}';
+    const items = entries
+      .map(([k, v]) => {
+        const key = IDENTIFIER_RE.test(k) ? k : toJsStringLiteral(k);
+        return `${pad}${key}: ${formatTSValue(v, indent + 2)}`;
+      })
+      .join(',\n');
+    return `{\n${items},\n${closePad}}`;
+  }
+
+  return String(value);
+};
+
+const formatJSONValue = (value, indent = 0) => {
   try {
-    return value ? JSON.stringify(value, null, 2) : undefined;
+    // Only `undefined` means "nothing to emit". A truthiness test would swallow
+    // legitimate falsy config such as `suppressMenuHide: false` or `rowHeight: 0`.
+    return value === undefined ? undefined : formatTSValue(value, indent);
   } catch (e) {
     console.warn('Could not serialise value to JSON', value, e);
   }

package/.genx/utils/formatRouteData.js

@@ -3,17 +3,36 @@ const {
   gridColumnsSerializer,
 } = require('./gridSerializers');
 const formatJSONValue = require('./formatJSONValue');
+const toJsStringLiteral = require('./toJsStringLiteral');
 const { getFormattedComment, getFormattedTodo } = require('./getTodosAndComments')
 const getLayoutType = require('./getLayoutType');
 const { COMPONENT_TYPE, FRAMEWORK_ANGULAR_ALIAS } = require('../static');
 
+// The factory the grid serialisers emit for an FDC3 click marker. It lives in the
+// generated src/utils/fdc3.ts, which is only written when FDC3EventHandlersEnabled
+// is true — so detection has to key off the very same marker the serialisers act on.
+const FDC3_EVENT_FACTORY = 'sendEventOnChannel';
+
+const DEFAULT_CONFIRM_MESSAGE = 'Are you sure you want to proceed?';
+
 const formatCustomEvents = (customEvents) => {
   if (!customEvents) return;
 
   return customEvents.map(event => ({
     ...event,
+    // Always a real boolean: the templates emit `hasForm: {{this.hasForm}},`
+    // and an omitted flag would otherwise render `hasForm: ,`.
+    hasForm: !!event.hasForm,
     uischema: event.hasForm ? formatJSONValue(event.uischema) : undefined,
     defaultValues: event.defaultValues ? formatJSONValue(event.defaultValues) : undefined,
+    // Ready-made JS string literals (quotes included) for the sites that emit
+    // JS rather than markup. Handlebars can only HTML-escape or not escape at
+    // all, and neither is correct for a JS literal: `{{ }}` turns `'` into
+    // `'` and `{{{ }}}` leaves the apostrophe to terminate the string.
+    tooltipJs: event.tooltip ? toJsStringLiteral(event.tooltip) : undefined,
+    confirmSubmitMessageJs: event.confirmSubmit
+      ? toJsStringLiteral(event.confirmSubmit.message || DEFAULT_CONFIRM_MESSAGE)
+      : undefined,
   }));
 };
 
@@ -24,10 +43,7 @@ const formatRouteData = (framework, route) => {
       ? 'tabs-panel'
       : route?.layoutType || getLayoutType(route);
 
-  const FDC3ClickCategory = 'fdc3';
-  const FDC3EventHandlersEnabled = !!route.tiles?.find(
-    (t) => t.config?.gridOptions?.onRowClicked?.category === FDC3ClickCategory,
-  );
+  let FDC3EventHandlersEnabled = false;
   const tiles = route.tiles?.map((tile, index) => {
     const config = tile.config || {};
     const metadata = tile.metadata || {};
@@ -47,31 +63,64 @@ const formatRouteData = (framework, route) => {
       eventing,
     } = config;
 
-    const hasFormatter = (name, colsOrOpts) => {
-      const cols = Array.isArray(colsOrOpts) ? colsOrOpts : colsOrOpts?.columns;
-      return cols?.some((col) => col.valueFormatter?.name === name);
-    };
+    const isSmartForm = tile.type === 'smart-form';
+
+    // A smart-form IS a create form, so `createFormUiSchema` and `uischema` name the
+    // same thing there. Normalise to `uischema` — the key every framework's form
+    // partial actually consumes — so the schema is wired into the form instead of
+    // being emitted as an unread constant (and so both keys together cannot emit
+    // two `createFormSchema` exports).
+    const effectiveUischema = isSmartForm ? uischema || createFormUiSchema : uischema;
+    const effectiveCreateFormUiSchema = isSmartForm ? undefined : createFormUiSchema;
+
+    // Permission code the whole tile is gated on, or null when it always renders.
+    // A smart-form has no read-only mode, so it is gated on updateRight; every
+    // other tile type renders for view-only users and uses updateRight solely to
+    // disable its CRUD affordances.
+    const { viewRight, updateRight } = config.permissions || {};
+    const wholeTileRight = viewRight || (isSmartForm ? updateRight : undefined) || null;
+    // `getViewUpdateRightComponent(getUser(), code)` is needed by the whole-tile
+    // gate and by the entity-manager CRUD props; emitting it anywhere else would
+    // leave unused imports behind.
+    const usesPermissionHelper =
+      !!wholeTileRight ||
+      !!(
+        tile.type === 'entity-manager' &&
+        updateRight &&
+        (config.createEvent || config.updateEvent || config.deleteEvent)
+      );
+
+    // An FDC3 marker can sit on any grid handler (onRowClicked, onCellClicked, ...)
+    // in either gridOptions or columns, so detect it from the serialised output —
+    // exactly what the templates' `ifContains ... 'sendEventOnChannel'` guards see.
+    const serialisedGridOptions = gridOptionsSerializer(gridOptions);
+    const serialisedColumns = gridColumnsSerializer(columns);
+    if (
+      serialisedGridOptions?.includes(FDC3_EVENT_FACTORY) ||
+      serialisedColumns?.includes(FDC3_EVENT_FACTORY)
+    ) {
+      FDC3EventHandlersEnabled = true;
+    }
 
     return {
       ...tile,
       componentName,
       componentType,
+      // JS string literal (quotes included) for the flexlayout tab names, which
+      // are emitted into a TS object rather than into markup.
+      titleJs: toJsStringLiteral(tile.title),
       config: {
         ...config,
         index,
-        gridOptions: gridOptionsSerializer(gridOptions),
+        wholeTileRight,
+        usesPermissionHelper,
+        gridOptions: serialisedGridOptions,
         useOnlyTemplateCols: !!gridOptions?.columns,
-        createFormUiSchema: formatJSONValue(createFormUiSchema),
+        createFormUiSchema: formatJSONValue(effectiveCreateFormUiSchema),
         updateFormUiSchema: formatJSONValue(updateFormUiSchema),
         filterFormUiSchema: formatJSONValue(filterFormUiSchema),
-        uischema: formatJSONValue(uischema),
-        columns: gridColumnsSerializer(columns),
-        hasNumberFormatter:
-          hasFormatter('getNumberFormatter', columns) ||
-          hasFormatter('getNumberFormatter', gridOptions),
-        hasDateFormatter:
-          hasFormatter('getDateFormatter', columns) ||
-          hasFormatter('getDateFormatter', gridOptions),
+        uischema: formatJSONValue(effectiveUischema),
+        columns: serialisedColumns,
         customEvents: formatCustomEvents(customEvents),
         eventing: {
           publishEventName: eventing?.publishEventName || null,

package/.genx/utils/generateTile.js

@@ -176,7 +176,16 @@ const getFilesToWrite = (
       }
       break;
     case 'smart-form':
-      filesToWrite.push(componentAddFormFile);
+      // Only write the schema module when there is a schema to export; a
+      // schema-less smart-form must not emit a file with unused imports. Both
+      // keys count: the component templates import createFormSchema for either
+      // one, so a file written for `uischema` alone would leave the
+      // `createFormUiSchema` variant importing a module that was never written.
+      // (formatRouteData normalises a smart-form's createFormUiSchema into
+      // uischema, so this is the belt to that braces.)
+      if (tileData.config?.uischema || tileData.config?.createFormUiSchema) {
+        filesToWrite.push(componentAddFormFile);
+      }
       break;
     default:
       break;

package/.genx/utils/gridSerializers.js

@@ -1,46 +1,86 @@
 const formatJSONValue = require('./formatJSONValue');
+const toJsStringLiteral = require('./toJsStringLiteral');
 
-function gridColumnsSerializer(columns, pad) {
-  if (!columns) {
-    return undefined;
+const FDC3_CLICK_CATEGORY = 'fdc3';
+
+// Emit string literals in oxfmt's own shape (singleQuote: true, with the
+// quote/escape choice prettier would make); JSON.stringify would always emit
+// double quotes and fail `oxfmt --check` out of the box.
+const serialiseFunctionArg = (arg) =>
+  typeof arg === 'string' ? toJsStringLiteral(arg) : JSON.stringify(arg);
+
+/**
+ * Serialises one `key: value` pair of a grid options object or of a column
+ * definition. Shared by both serializers so the special value shapes
+ * (function/valueFormatter factories, FDC3 click markers) are handled
+ * identically wherever they are authored.
+ *
+ * @param {string} key property name
+ * @param {unknown} value property value
+ * @param {number} indent indentation of the emitted line
+ * @returns {string} the emitted line(s), trailing comma included
+ */
+function serialiseEntry(key, value, indent) {
+  const pad = ' '.repeat(indent);
+
+  if (value?.type === 'function' || value?.type === 'valueFormatter') {
+    const args = value.arguments?.map(serialiseFunctionArg).join(', ');
+    return `${pad}${key}: ${value.name}(${args}),`;
+  }
+
+  if (value?.category === FDC3_CLICK_CATEGORY) {
+    // FDC3 click markers are authored as { category: 'fdc3', channelName, type } and are
+    // detected by formatRouteData (FDC3EventHandlersEnabled). AG Grid handlers such as
+    // onRowClicked must be functions, so emit the sendEventOnChannel factory call that the
+    // generated src/utils/fdc3.ts provides instead of leaking the raw marker object.
+    const args = [value.channelName, value.type].map(serialiseFunctionArg).join(', ');
+    // prettier-ignore pin: channel/type are user data, so the emitted call can exceed the
+    // print width; the pin keeps the single-line form stable either way.
+    return `${pad}// prettier-ignore\n${pad}${key}: sendEventOnChannel(${args}),`;
   }
 
+  return `${pad}${key}: ${formatJSONValue(value, indent)},`;
+}
+
+function gridColumnsSerializer(columns, indent = 0) {
+  if (!columns) return undefined;
+
   try {
-    const columnsSerialized = columns.map((column) => {
-      return gridOptionsSerializer(column, pad);
+    // An expanded empty array would serialise as `[\n,\n]`; emit the literal instead.
+    if (!columns.length) return '[]';
+    const pad = ' '.repeat(indent);
+    const itemPad = ' '.repeat(indent + 2);
+    const items = columns.map((column) => {
+      const fields = Object.entries(column)
+        .map(([k, v]) => serialiseEntry(k, v, indent + 4))
+        .join('\n');
+      return `${itemPad}{\n${fields}\n${itemPad}}`;
     });
-    return `[${columnsSerialized}\n]`;
+    return `[\n${items.join(',\n')},\n${pad}]`;
   } catch (e) {
     console.error('Error serializing grid columns:', e.message);
     throw e;
   }
 }
 
-function gridOptionsSerializer(options, pad = '  ') {
-  if (!options) {
-    return undefined;
-  }
+function gridOptionsSerializer(options, indent = 0) {
+  if (!options) return undefined;
 
   try {
-    let output = `\n${pad}{\n`;
+    const pad = ' '.repeat(indent);
+    const itemPad = ' '.repeat(indent + 2);
+    let fields = '';
     Object.keys(options).forEach((key) => {
       const value = options[key];
       if (key === 'columns') {
-        output += `${pad}${pad}${'columnDefs'}: ${gridColumnsSerializer(value, '     ')},\n`;
-      } else if (
-        value?.type === 'function' ||
-        value?.type === 'valueFormatter'
-      ) {
-        const args = value.arguments?.map(JSON.stringify).join(', ');
-        output += `${pad}${pad}${key}: ${value.name}(${args}),\n`;
-      } else if (key === 'hide') {
-        output += `${pad}${pad}${key}: ${value},\n`;
+        fields += `${itemPad}columnDefs: ${gridColumnsSerializer(value, indent + 2)},\n`;
       } else {
-        output += `${pad}${pad}${key}: ${formatJSONValue(value)},\n`;
+        fields += `${serialiseEntry(key, value, indent + 2)}\n`;
       }
     });
-    output += `${pad}}`;
-    return output;
+    // An expanded empty object is what oxfmt collapses to `{}`; match formatTSValue.
+    if (!fields) return '{}';
+    return `{\n${fields}${pad}}`;
   } catch (e) {
     console.error('Error serializing grid options:', e.message);
     throw e;

package/.genx/utils/registerPartials.js

@@ -8,24 +8,27 @@ const registerPartials = ({ registerPartial }, framework) => {
   // It can be reverted after adding changes for angular
   const sourceTemplateDir = `../${DIR_TEMPLATE_BY_FRAMEWORK[framework]}`;
 
+  // Angular always renders through the 'tabs-panel' layout (see formatRouteData),
+  // so the grid/tabs/horizontal layout partials only exist for the other frameworks.
   if (framework === FRAMEWORK_ANGULAR_ALIAS) {
     registerPartial(
       'tabs-panel',
       resolve(__dirname, `${sourceTemplateDir}/tabsPanel.hbs`),
     );
+  } else {
+    registerPartial(
+      'grid-layout',
+      resolve(__dirname, `${sourceTemplateDir}/gridLayout.hbs`),
+    );
+    registerPartial(
+      'tabs-layout',
+      resolve(__dirname, `${sourceTemplateDir}/tabsLayout.hbs`),
+    );
+    registerPartial(
+      'horizontal-layout',
+      resolve(__dirname, `${sourceTemplateDir}/horizontalLayout.hbs`),
+    );
   }
-  registerPartial(
-    'grid-layout',
-    resolve(__dirname, `${sourceTemplateDir}/gridLayout.hbs`),
-  );
-  registerPartial(
-    'tabs-layout',
-    resolve(__dirname, `${sourceTemplateDir}/tabsLayout.hbs`),
-  );
-  registerPartial(
-    'horizontal-layout',
-    resolve(__dirname, `${sourceTemplateDir}/horizontalLayout.hbs`),
-  );
   registerPartial(
     'smart-form',
     resolve(__dirname, `${sourceTemplateDir}/form.hbs`),