Inflow.aiDocs

Optional technical reference. This material is for developers, integration specialists and platform administrators. For the consultant lesson, read the practical guide.

Preserved from source baseline d4587c7c0e073e58c2d430342f65ac55dd701bf4; source/static examples retain their stated scope. They are not new runtime verification or required consultant setup steps.

Current model-key correction — 8 November 2026. The preserved examples below contain historical camelCase record-type/field keys. Do not copy those keys into the current editor or API: use record type leave_request and the lowercase field keys in the current model worksheet, including request_id, employee_id, manager_id, start_date, end_date, requested_days and decision_comment. Form, rule and case input names are separate declarations; map them explicitly rather than mechanically renaming every input. The preserved body remains historical source material, not a current executable model payload.

Current product update — 9 November 2026. App Chat is now an implemented optional App Shell feature, configured separately from query-driven pages and their data controls. Connecting a Data Grid or query does not automatically make that data an App Chat source; the shell owner must add an offered source and review its allowed operations and fields. References below to “separately planned” App Chat are historical; they mean that App Chat is not enabled by these existing query controls. For the current configuration, see the App Chat lesson. This update does not claim a specific app's query or chat runtime was exercised.

Build a governed query-driven application view

This tutorial continues the leave data/rules foundation. It teaches the boundary from a published source/rule to a saved screen draft and immutable runtime query. It complements App Shell/interface building; that tutorial owns the complete shared layout/control/publication journey.

The story actors are Nadia (builder), Mohammad (employee) and Sara (manager), with real sessions and scoped grants from the identity lab. A plain employeeId field is business data, not automatic row security. The application must use its actual admitted source and authorization design.

Read path What the browser chooses What stays server-owned
Authoring catalog/preview Bounded selected source/fields in saved draft context Source discovery/authorization, shape and contributor limits.
Published record grid Version/node plus supported viewport controls Source/model/publication, projection and stable key.
Supported QUERY grid Its native bounded viewport contract Exact published rule/node and admitted query subset.
QUERY Repeater Version/node and supported opaque cursor Immutable no-caller-input rule, projection and collection limits.

All synthetic IDs/versions below need actual fixture replacements. These are source-reviewed procedures, not a recording or fresh product runtime certification. Do not create a hidden provider call, use another user’s preview cache or bypass a held service operation to make the example appear complete.

Milestone 1 — Confirm the source and expected result before designing a screen

Scenario and inputs. Use the data/rule handoff from the first tutorial: an exact applied leaveRequest source and three synthetic rows. Nadia is the permitted builder; Sara’s published viewer context is separate. Expected training rows are 014PENDING,015PENDING and 016APPROVED, subject to the actual source’s declared authorization.

Procedure. 1. Inspect the actual model version/type/publication and its readable fields. 2. Decide whether the first screen should use direct published records or a reusable QUERY; do not choose by matching labels alone. 3. Write the minimum projection: requestId, relevant dates, requestedDays and status. 4. Retain the primary-key metadata that will drive row identity, independent from the displayed business requestId. 5. Confirm that employeeId/status filters narrow a business question but do not constitute native user-access policy.

Expected result. The reader can predict the intended business subset before connecting any control. The exact source and row identity are known; absence, denial and zero matches remain separate conditions.

Failure and recovery. If several applied destinations or same-named types exist, choose the actual intended publication and version. Do not take the first/newest result from an unscoped catalog. If Sara’s intended source admission is missing, resolve that actual application/model boundary before offering a link.

Sources. DataModelRecordsController.java, PublishedRecordDataSourceContributor.java.

Milestone 2 — Create a query with deliberate shape and input semantics

Scenario and inputs. Nadia needs a list of pending requests, with a known projection and stable row identity. A second view will ask only whether any pending request exists. The two views must not accidentally share an incompatible scalar/record contract.

Procedure. 1. Create a QUERY in the normal rule builder and select the exact published source. 2. Choose List of records and the explicit projection for the list view. 3. For a fixed-status no-input training query, author the actual quoted PENDING literal through the guided filter. For an input-driven variation, declare TEXT status and use inputs:status in the expression editor without accidental literal quoting. 4. Choose a bounded result size and validate expression/designer round-trip. 5. Create/test the separate Exists or Count variation only when a consumer needs that scalar answer.

Expected result. The no-input list contract can be evaluated by consumers that genuinely require no inputs; an input-driven query advertises its required values. A scalar result is not offered as a reusable record collection simply because its name resembles the list query.

Failure and recovery. If the builder cannot represent an edited expression without loss, keep Expression mode and its explicit unsupported reason. Do not silently drop a filter or coerce a scalar into a fake row array to fit a control.

Sources. QueryRuleRuntime.java, QueryBuilderExpressionCodec.java.

Milestone 3 — Choose DataGrid, Table or Repeater from real capabilities

Scenario and inputs. The application needs an interactive manager list. Nadia can choose among several visual collection controls, but their transport and server-execution contracts differ. A catalog collection alone does not establish arbitrary server paging or permit caller-defined inputs.

Procedure. 1. Inspect the reusable result’s declared shape/identity and the selected control’s actual source adapter. 2. For a direct published-record DataGrid, call the native selected-source grid-capability preflight through the designer and keep Apply unavailable until it reports a supported source. 3. For QUERY grids, require the actual supported serverPaged/search/filter/sort subset rather than enabling every query. 4. For Repeater, choose only the supported exact immutable no-caller-input QUERY path. 5. If the result cannot satisfy that adapter, choose a genuinely supported control/mapping instead of hand-adding request fields.

Expected result. A supported control is selected with an explicit reason: structured paged grid, compatible table or bounded repeated item rendering. It preserves the native runtime boundary that will authorize the source and reconstruct saved node identity.

Failure and recovery. A required-input query that cannot be bound by the chosen adapter remains unavailable. Do not edit the browser payload to send arbitrary rule keys/fields or disguise a disabled category as a successful preview. The grid manual describes the actual request distinctions.

Sources. DataGridQueryController.java, RuleQueryCollectionController.java.

Milestone 4 — Connect and preview through the saved draft

Scenario and inputs. Nadia has selected a supported control in a saved screen draft. She needs to verify fields, source identity and sample shape before publication, using her authoring context. Sara’s later published result cannot reuse Nadia’s preview data as an authorization shortcut.

Procedure. 1. Open the control’s actual Connect data flow and discover the selected source from /api/screens/{screenKey}/data-sources. 2. Inspect its sourceRef/version/path/publication, shape, capabilities and any inference ambiguity. 3. Choose an explicit projection and bounded preview; retain contributor fingerprints/choices where required. 4. Confirm pending versus approved fixture rows behave as intended and a zero-result query is not confused with disabled/unavailable preview. 5. Apply the source through the designer, retaining stable node ID and row key metadata. 6. Save the exact draft revision before the native publication/impact review.

Expected result. The saved draft contains a coherent source and projection, and the preview is only an authoring observation under Nadia’s access. It does not publish the screen or grant Sara field/model access.

Failure and recovery. If the preview is unavailable, fix the exact source/shape/input/capability problem. Do not invent demo rows to finish the wizard, use another actor’s cached data or guess a collection when inference is ambiguous. A changed source fingerprint requires the contributor’s real re-review path.

Sources. DataSourceCatalogController.java, DataSourcePreview.java.

Milestone 5 — Publish and read an immutable grid node

Scenario and inputs. Nadia has reviewed the saved screen and source. Sara is admitted through the actual published application/screen boundary. The ordinary grid example below is a complete request body for a compatible published-record node; it must not be sent to the separate Repeater or QUERY-grid route unchanged.

Procedure. 1. Complete the screen’s native publication-impact and revision/idempotency flow as described in the App Shell tutorial. 2. Retain the actual published screen key/version and node ID. 3. Open the published screen as Sara, letting the normal control issue its bounded native query. 4. When inspecting developer evidence, compare the request with the closed body shown below. 5. Render only returned rows/projection, preserve canonical row-key values and derive authorized totals from the actual response, not page length. 6. Verify the request did not include caller-supplied model/rule/projection authority.

{
  "version": 3,
  "nodeId": "requestsGrid",
  "search": "",
  "filters": [
    {
      "field": "status",
      "operator": "eq",
      "value": "PENDING"
    }
  ],
  "sort": {
    "field": "requestId",
    "direction": "asc"
  },
  "page": {
    "index": 0,
    "size": 25
  }
}

Expected result. The server reloads the immutable node, checks screen/source authorization and derives the actual source. A page can be valid even when its total exceeds returned items; a numeric key remains an identity string where the wire contract requires it.

Failure and recovery. A stale/unknown node, unauthorized model, duplicate row identity or unsupported filter must remain a real refusal. Reopen the intended publication or correct/republish the source contract. Never silently swap in the newest draft or widen field requests because a view failed.

Sources. DataGridQueryController.java, ScreenDefinitionController.java.

Milestone 6 — Exercise failures and hand rows to real actions

Scenario and inputs. The list is useful only if its identity and authorization survive user interactions. Nadia prepares a precision-sensitive numeric fixture and a denied/unsupported source case alongside the normal pending list. Sara’s manager decision remains a separate native task/form action.

Procedure. 1. Verify two large numeric identities remain distinct and exact DECIMAL filters preserve their canonical input representation. 2. Try a declared one-to-one related field only when the selected source advertises the actual bounded relationship capability. 3. Confirm unsupported one-to-many/cross-source paths and unknown nested request properties are refused. 4. Open an individual record or task only through the actual returned identity/native navigation; do not derive a task ID from requestId. 5. Complete the separate human-task tutorial for approval and refresh this list after an accepted business result, not merely after a UI button click.

Expected result. The application’s list, detail and action boundaries remain explicit. A status glyph or row selection does not mutate the request, and an unknown mutation outcome cannot be hidden by locally changing the displayed status.

Failure and recovery. For lost/uncertain actions, reconcile the owning task/record intent/receipt rather than replaying the grid request as an update. For revoked access, use the neutral unavailable behavior and stop unauthorized detail/catalog requests. Record source/static and actual runtime outcomes separately.

Sources. DataGridQueryController.java, DataModelRecordsController.java.

Acceptance and onward path

The learning outcome is not simply “the page loaded.” The reader should be able to identify the exact published source and screen version, explain the chosen adapter and row identity, predict normal and denied results, and distinguish a bounded page from an authorized total. Keep schema/permission/dependency failures unavailable, not successful zero rows.

Continue to vacation workflow and human tasks for the actual manager decision and canonical completion receipt, document workflow for attachments, and deployment/operations for moving the reviewed application. The separately planned floating App Chat is not a feature enabled by connecting these existing controls.

Try “document generation”, “integrations” or “first form”.