@genesislcap/mock-server 15.53.0 → 15.55.0

package/dist/db/views.js

@@ -0,0 +1,193 @@
+// The view join model, as GSF 8.15.x views behave (genesis-pal
+// view/join/*.kt, ViewStructureReaderImpl.kt; genesis-codegen
+// ViewRepoConfigGenerator.kt): a base table, joins that each start from the
+// base or an earlier join, matched on one or more key links, INNER or OUTER,
+// plus derived fields. A ViewDef is planned into the form the store
+// materializes from, the schema types from and live propagation reads.
+const isFieldPair = (on) => on.length === 2 && typeof on[0] === 'string' && typeof on[1] === 'string';
+// A pair, and an object link with no `fromAlias`, read from the join's own
+// `fromAlias`. A join with none reads them from the view row built so far —
+// the base row's columns, overlaid by the selects of the joins before it —
+// as joins always have, so one written before `fromAlias` existed can still
+// key on an earlier join's selected column. For a GSF view that is the base
+// row's field (an alias never repeats a base column the view exposes); name
+// `fromAlias` to read one table's own row.
+function linksOf(on, fromAlias) {
+    const links = isFieldPair(on) ? [on] : on;
+    return links.map((link) => {
+        if (Array.isArray(link))
+            return { kind: 'field', fromAlias, from: link[0], to: link[1] };
+        if ('value' in link)
+            return { kind: 'value', to: link.to, value: link.value };
+        return { kind: 'field', fromAlias: link.fromAlias ?? fromAlias, from: link.from, to: link.to };
+    });
+}
+// The plan of a view. Planned on every use (it costs next to nothing), so a
+// definition changed in place takes effect, as it always has. Throws on a
+// definition GSF would refuse to compile: a join with no `on` link, an alias
+// given twice, or a join (or one of its links) reading from a table that is
+// neither the base nor an earlier join.
+//
+// Before aliases existed, a table could be joined twice (or the base table
+// joined to itself) with no alias, and such configs keep working: a join
+// with no alias whose table name an earlier table already goes by (one
+// without an explicit alias either) is joined as before, but goes by no name
+// — the name keeps meaning the earlier table. Give it an `alias` to read it.
+export function planView(viewName, view) {
+    const fail = (message) => {
+        throw new Error(`[mock-server] View ${viewName}: ${message}`);
+    };
+    const baseAlias = view.baseAlias ?? view.base;
+    // Every name so far: whether it was given explicitly, and whether a row
+    // under it always exists when the view row does.
+    const names = new Map([
+        [baseAlias, { explicit: view.baseAlias !== undefined, alwaysMatched: true }],
+    ]);
+    const checkSource = (label, alias) => {
+        if (alias !== undefined && !names.has(alias)) {
+            fail(`${label} reads from '${alias}', which is neither the base nor an earlier join`);
+        }
+    };
+    const joins = (view.joins ?? []).map((def, index) => {
+        const name = def.alias ?? def.table;
+        const fromAlias = def.fromAlias ?? baseAlias;
+        const label = `join ${index + 1} (${name})`;
+        checkSource(label, fromAlias);
+        const links = linksOf(def.on, def.fromAlias);
+        if (links.length === 0)
+            fail(`${label} has no 'on' link`);
+        for (const link of links)
+            if (link.kind === 'field')
+                checkSource(label, link.fromAlias);
+        const taken = names.get(name);
+        if (taken && (taken.explicit || def.alias !== undefined)) {
+            fail(`${label}: alias '${name}' is already used; give each table its own alias`);
+        }
+        const inner = def.type === 'INNER';
+        const alwaysMatched = inner && names.get(fromAlias).alwaysMatched;
+        if (!taken)
+            names.set(name, { explicit: def.alias !== undefined, alwaysMatched });
+        return {
+            def,
+            table: def.table,
+            alias: taken ? undefined : name,
+            fromAlias,
+            links,
+            inner,
+            backwardsJoin: def.backwardsJoin === true,
+            alwaysMatched,
+        };
+    });
+    const antiJoins = (view.antiJoins ?? []).map((def, index) => {
+        const label = `anti-join ${index + 1} (${def.table})`;
+        const links = linksOf(def.on, undefined);
+        if (links.length === 0)
+            fail(`${label} has no 'on' link`);
+        for (const link of links) {
+            if (link.kind === 'field' && link.fromAlias !== undefined && link.fromAlias !== baseAlias) {
+                fail(`${label} can only read from the base table`);
+            }
+        }
+        return { def, table: def.table, links };
+    });
+    return { baseAlias, joins, antiJoins };
+}
+const KEY_SEPARATOR = '\u0000';
+// One index key for a list of values, or undefined when one is null or
+// missing: GSF builds no join request from a null key, so it matches nothing.
+// Typed, so 1 and '1' differ, as === tells them apart.
+function keyOf(values) {
+    if (values.some((value) => value === undefined || value === null))
+        return undefined;
+    return values.map((value) => `${typeof value}:${String(value)}`).join(KEY_SEPARATOR);
+}
+// Finds a join's match for one view row: the joined rows whose fields equal
+// the source fields (an index over them, built once), narrowed by the
+// constants and the `where` predicate. GSF only lets a dataserver read a view
+// whose joins are one-to-one (their links cover a unique index), so a valid
+// view has at most one match; when there are more, the last one in table
+// order wins — with a `where`, the first that passes — as before this model.
+function matcher(links, where, rows) {
+    const fieldLinks = links.flatMap((link) => (link.kind === 'field' ? [link] : []));
+    const valueLinks = links.flatMap((link) => (link.kind === 'value' ? [link] : []));
+    let index;
+    const candidatesFor = (viewRow, sources) => {
+        if (fieldLinks.length === 0)
+            return rows;
+        if (!index) {
+            index = new Map();
+            for (const row of rows) {
+                const key = keyOf(fieldLinks.map((link) => row[link.to]));
+                if (key === undefined)
+                    continue;
+                const bucket = index.get(key);
+                if (bucket)
+                    bucket.push(row);
+                else
+                    index.set(key, [row]);
+            }
+        }
+        const key = keyOf(fieldLinks.map((link) => link.fromAlias === undefined
+            ? viewRow[link.from]
+            : sources.tables[link.fromAlias]?.[link.from]));
+        return key === undefined ? [] : (index.get(key) ?? []);
+    };
+    const constantsHold = (row) => valueLinks.every((link) => row[link.to] === link.value);
+    return (viewRow, sources) => {
+        const candidates = candidatesFor(viewRow, sources);
+        if (where) {
+            return candidates.find((row) => constantsHold(row) && where(row, viewRow, sources));
+        }
+        return candidates.findLast(constantsHold);
+    };
+}
+// The view's rows: each base row without an anti-joined match, joined in
+// order (an INNER join with no match drops the row; a join whose source
+// found nothing finds nothing either), plus the base `select` aliases, each
+// join's `select` and the derived fields.
+export function materializeEntries(viewName, view, source) {
+    const plan = planView(viewName, view);
+    const antiJoins = plan.antiJoins.map((antiJoin) => matcher(antiJoin.links, antiJoin.def.where, source.rowsOf(antiJoin)));
+    const joins = plan.joins.map((join) => matcher(join.links, join.def.where, source.rowsOf(join)));
+    const entries = [];
+    for (const base of source.base) {
+        const sources = { tables: { [plan.baseAlias]: base } };
+        if (antiJoins.some((match) => match(base, sources)))
+            continue;
+        const row = { ...base };
+        for (const [name, field] of Object.entries(view.select ?? {}))
+            row[name] = base[field];
+        const matches = [];
+        let dropped = false;
+        for (const [index, join] of plan.joins.entries()) {
+            // `where` sees the view row so far, as it always has: the base row's
+            // columns and the selects before this join.
+            const match = sources.tables[join.fromAlias] ? joins[index](row, sources) : undefined;
+            if (!match && join.inner) {
+                dropped = true;
+                break;
+            }
+            matches.push(match);
+            if (join.alias !== undefined)
+                sources.tables[join.alias] = match;
+            for (const [name, field] of Object.entries(join.def.select ?? {}))
+                row[name] = match?.[field];
+        }
+        if (dropped)
+            continue;
+        if (!view.derived) {
+            entries.push({ row, matches });
+            continue;
+        }
+        const derived = { ...row };
+        for (const [name, compute] of Object.entries(view.derived)) {
+            derived[name] = compute(row, sources);
+        }
+        entries.push({ row: derived, matches });
+    }
+    return entries;
+}
+// The planned joins and anti-joins that read a table.
+export function entriesReading(plan, tableName) {
+    return [...plan.joins, ...plan.antiJoins].filter((entry) => entry.table === tableName);
+}

package/dist/index.d.ts

@@ -4,4 +4,4 @@ export { Store } from './db/store.ts';
 export { RECORD_FIELDS, RECORD_ID, TIMESTAMP } from './db/identity.ts';
 export { ErrorCode, NackError, statusCodeFor, type ErrorCodeName, type GenesisErrorType, type NackErrorEntry, type NackErrorInput, type NackErrorOptions, } from './protocol/errors.ts';
 export { compileCriteria, filterByCriteria, type Predicate } from './db/criteria.ts';
-export type { AntiJoinDef, AuthConfig, AuthUser, BroadcastFn, BroadcastTableChangeFn, CrudEventVerb, EventHandler, EventHandlerCtx, EventHandlerResult, EventSchemaOverride, FidelityMode, FieldDef, FieldMetadata, GeneratedFieldDef, GenesisFieldType, GenesisMessage, HttpRouteDef, IndexDef, JoinDef, MockServerConfig, OnMessageCtx, OnMessageHook, QueryDef, RequestingUser, RequestReplyDef, RequestReplyResolverCtx, ResourceAuthDef, ResourceItem, Row, SequenceFormat, SocketLike, SsoIdentityProvider, TableDef, ViewDef, } from './types.ts';
+export type { AntiJoinDef, AuthConfig, AuthUser, BroadcastFn, BroadcastTableChangeFn, CrudEventVerb, EventHandler, EventHandlerCtx, EventHandlerResult, EventSchemaOverride, FidelityMode, FieldDef, FieldMetadata, GeneratedFieldDef, GenesisFieldType, GenesisMessage, HttpRouteDef, IndexDef, JoinDef, JoinFieldLink, JoinLink, JoinType, JoinValueLink, MockServerConfig, OnMessageCtx, OnMessageHook, QueryDef, RequestingUser, RequestReplyDef, RequestReplyResolverCtx, ResourceAuthDef, ResourceItem, Row, SequenceFormat, SocketLike, SsoIdentityProvider, TableDef, ViewDef, ViewRowSources, } from './types.ts';

package/dist/server.js

@@ -1,6 +1,8 @@
 import http from 'node:http';
 import { WebSocketServer } from 'ws';
+import { recordKey } from "./db/identity.js";
 import { Store } from "./db/store.js";
+import { entriesReading, planView, } from "./db/views.js";
 import { crudEventHandler } from "./handlers/crudEvents.js";
 import { pendingKey } from "./handlers/dataLogon.js";
 import { createHttpRequestListener } from "./handlers/http.js";
@@ -9,6 +11,17 @@ import { Connection } from "./protocol/connection.js";
 import { isLegacyFidelity } from "./protocol/fidelity.js";
 import { routeMessage } from "./protocol/router.js";
 import { dataserverRow, stampRow } from "./protocol/rowUpdate.js";
+// Whether two rows carry the same columns and values (a value compared as
+// JSON when it isn't the same primitive).
+function sameValues(a, b) {
+    const keys = new Set([...Object.keys(a), ...Object.keys(b)]);
+    for (const key of keys) {
+        if (!Object.is(a[key], b[key]) && JSON.stringify(a[key]) !== JSON.stringify(b[key])) {
+            return false;
+        }
+    }
+    return true;
+}
 export function createMockServer(config) {
     const store = new Store();
     for (const [tableName, tableDef] of Object.entries(config.tables ?? {})) {
@@ -189,6 +202,101 @@ export function createMockServer(config) {
         for (const record of records)
             pushChange(resourceName, 'DELETE', record);
     };
+    // A change being broadcast to a table, as the views that join it see it:
+    // the table's rows before and after it, and the RECORD_IDs it touched (the
+    // changed record and every record its key lost). The store's
+    // previous-record entries are consumed straight away, so the next change
+    // starts from this one; the rows are only gathered if a view needs them.
+    function tableChange(tableName, operation, current, removed) {
+        const currentId = recordKey(current);
+        const previous = current ? store.takePreviousRecord(tableName, current) : undefined;
+        const lost = new Map(removed.map((record) => [
+            recordKey(record),
+            store.takePreviousRecord(tableName, record) ?? record,
+        ]));
+        // The changed record was in the table before as it was before its first
+        // modify — or as it is, when nothing modified it. An INSERT's wasn't, nor
+        // was one that replaced another record under its key.
+        const currentWasThere = operation !== 'INSERT' && (previous !== undefined || lost.size === 0);
+        const records = new Set([currentId, ...lost.keys()].filter((id) => id !== undefined));
+        let before;
+        return {
+            records,
+            before: () => {
+                if (before)
+                    return before;
+                const restored = new Set();
+                before = store.getAllRows(tableName).flatMap((row) => {
+                    const id = recordKey(row);
+                    if (id !== undefined && id === currentId) {
+                        return currentWasThere ? [previous ?? row] : [];
+                    }
+                    // A record a DELETE names before it is removed.
+                    if (lost.has(id)) {
+                        restored.add(id);
+                        return [lost.get(id)];
+                    }
+                    return [row];
+                });
+                for (const [id, record] of lost)
+                    if (!restored.has(id))
+                        before.push(record);
+                return before;
+            },
+            // Without the records the key lost, even one still stored when its
+            // DELETE is broadcast.
+            after: () => store.getAllRows(tableName).filter((row) => !lost.has(recordKey(row))),
+        };
+    }
+    // A live change to a table a view joins (at any depth) or anti-joins, under
+    // fidelity 'gsf'. Only the joins that read the table with `backwardsJoin`
+    // listen to it — GSF listens to no other joined table — and every
+    // anti-join does. The view is rebuilt through them as it was before the
+    // change and as it is after it, and compared, row by base record (the
+    // ROW_REF): a row the change brought in (an INNER join that now matches) is
+    // pushed as an INSERT, one it took out as a DELETE, and one joined to a
+    // changed record before or after, or whose values changed, as a MODIFY.
+    // A row joined to the changed record is pushed even when its values look
+    // the same: the before-state is the store's (a record as it was before its
+    // first unannounced modify), and a client may hold newer values than that.
+    // A view that joins its own base table gets the changed base rows
+    // themselves from broadcastTableChange's base path, not from here.
+    function joinedViewChanges(viewName, view, tableName, change) {
+        const plan = planView(viewName, view);
+        const listening = entriesReading(plan, tableName).filter((entry) => !('backwardsJoin' in entry) || entry.backwardsJoin);
+        if (listening.length === 0)
+            return [];
+        // By definition: every materialization plans the view afresh.
+        const listeningDefs = new Set(listening.map((entry) => entry.def));
+        const listeningJoins = plan.joins.flatMap((join, index) => listeningDefs.has(join.def) ? [index] : []);
+        const touched = ({ matches }) => listeningJoins.some((index) => {
+            const id = recordKey(matches[index]);
+            return id !== undefined && change.records.has(id);
+        });
+        const rowsOf = (rows) => (entry) => listeningDefs.has(entry.def) ? rows() : undefined;
+        const was = store.getViewEntriesFrom(viewName, { rowsOf: rowsOf(change.before) });
+        const now = store.getViewEntriesFrom(viewName, { rowsOf: rowsOf(change.after) });
+        const ownRow = (entry) => view.base === tableName && change.records.has(recordKey(entry.row) ?? '');
+        const wasByRecord = new Map(was.map((entry) => [recordKey(entry.row), entry]));
+        const nowRecords = new Set(now.map((entry) => recordKey(entry.row)));
+        const changes = [];
+        for (const entry of now) {
+            if (ownRow(entry))
+                continue;
+            const old = wasByRecord.get(recordKey(entry.row));
+            if (!old)
+                changes.push(['INSERT', entry.row]);
+            else if (touched(old) || touched(entry) || !sameValues(old.row, entry.row)) {
+                changes.push(['MODIFY', entry.row]);
+            }
+        }
+        for (const entry of was) {
+            if (!ownRow(entry) && !nowRecords.has(recordKey(entry.row))) {
+                changes.push(['DELETE', entry.row]);
+            }
+        }
+        return changes;
+    }
     // Event handlers mutate one table (e.g. TRADE) but grids may be subscribed to
     // a view built on top of it (e.g. ALL_TRADES -> TRADE_VIEW). This finds every
     // query resource backed by that table — directly or via a view — and pushes
@@ -201,9 +309,12 @@ export function createMockServer(config) {
     // re-inserted, before one broadcast) gets a DELETE of its old ROW_REF before
     // the new one goes out. A view row is built from the changed base row
     // alone, so it is found whatever the view's own pkField; a MODIFY that takes
-    // it out of the view (an anti-join) is pushed as a DELETE. Legacy ROW_REFs
-    // are the key itself, so there a DELETE is the pk stub and a replacement is
-    // the one INSERT/MODIFY, as before.
+    // it out of the view (an INNER join or an anti-join that no longer lets it
+    // through) is pushed as a DELETE, and an INSERT that doesn't make it into
+    // the view isn't pushed at all. A table a view joins is handled by
+    // joinedViewChanges. Legacy ROW_REFs are the key itself, so there a DELETE
+    // is the pk stub and a replacement is the one INSERT/MODIFY, as before; and
+    // a change to a joined table pushes every view row as a MODIFY.
     const broadcastTableChange = (tableName, operation, pk) => {
         const legacy = isLegacyFidelity(config);
         const current = operation === 'DELETE' ? undefined : store.getRow(tableName, pk);
@@ -214,30 +325,38 @@ export function createMockServer(config) {
         const live = store.getRow(tableName, pk);
         if (operation === 'DELETE' && removed.length === 0 && live)
             removed = [live];
+        const change = tableChange(tableName, operation, current, removed);
         if (legacy)
             removed = [];
+        const viewChanges = new Map();
         for (const [queryName, query] of Object.entries(config.queries ?? {})) {
             const isDirect = query.source === tableName;
             const view = store.views.get(query.source);
             const isViewOnTable = view?.base === tableName;
-            // A view that JOINS (or anti-joins) the mutated table denormalizes its
-            // columns into every matching base row, so one change can affect any
-            // number of view rows — none of them keyed by `pk`. Re-materialize and
-            // push the refreshed view instead of dropping the change, or e.g.
-            // renaming a COUNTERPARTY never updates COUNTERPARTY_NAME in an open
-            // ALL_TRADES grid.
-            const isViewJoiningTable = !isDirect &&
+            if (view && !legacy) {
+                let changes = viewChanges.get(query.source);
+                if (!changes) {
+                    changes = joinedViewChanges(query.source, view, tableName, change);
+                    viewChanges.set(query.source, changes);
+                }
+                for (const [rowOperation, row] of changes)
+                    pushChange(queryName, rowOperation, row);
+            }
+            // Legacy: a view that JOINS (or anti-joins) the mutated table
+            // denormalizes its columns into any number of view rows, so the view is
+            // re-materialized and every row pushed as a MODIFY.
+            if (legacy &&
+                !isDirect &&
                 !isViewOnTable &&
                 ((view?.joins ?? []).some((join) => join.table === tableName) ||
-                    (view?.antiJoins ?? []).some((antiJoin) => antiJoin.table === tableName));
-            if (!isDirect && !isViewOnTable && !isViewJoiningTable)
-                continue;
-            if (isViewJoiningTable) {
+                    (view?.antiJoins ?? []).some((antiJoin) => antiJoin.table === tableName))) {
                 for (const viewRow of store.getViewRows(query.source)) {
                     pushChange(queryName, 'MODIFY', viewRow);
                 }
                 continue;
             }
+            if (!isDirect && !isViewOnTable)
+                continue;
             // The removed base records carry the RECORD_ID a view row's ROW_REF
             // comes from too; the DELETE body is DETAILS only either way.
             for (const record of removed)
@@ -256,7 +375,9 @@ export function createMockServer(config) {
                 pushChange(queryName, operation, current);
                 continue;
             }
-            const viewRow = store.getViewRows(query.source, { [tableName]: [current] })[0];
+            // Only the base read is narrowed: a view that also joins its base table
+            // still joins every row of it.
+            const viewRow = store.getViewRowsFrom(query.source, { base: [current] })[0];
             if (viewRow) {
                 pushChange(queryName, operation, viewRow);
             }

package/dist/types.d.ts

@@ -44,23 +44,44 @@ export interface TableDef {
     events?: CrudEventVerb[];
 }
 export type SequenceFormat = 'prefix' | 'genesis';
+export type JoinFieldLink = [string, string];
+export interface JoinAliasedFieldLink {
+    fromAlias?: string;
+    from: string;
+    to: string;
+}
+export interface JoinValueLink {
+    to: string;
+    value: unknown;
+}
+export type JoinLink = JoinFieldLink | JoinAliasedFieldLink | JoinValueLink;
+export type JoinType = 'INNER' | 'OUTER';
+export interface ViewRowSources {
+    tables: Record<string, Row | undefined>;
+}
 export interface JoinDef {
     table: string;
-    on: [string, string];
+    alias?: string;
+    fromAlias?: string;
+    on: JoinFieldLink | JoinLink[];
+    type?: JoinType;
+    backwardsJoin?: boolean;
     select?: Record<string, string>;
-    where?: (joinRow: Row, baseRow: Row) => boolean;
+    where?: (joinRow: Row, viewRow: Row, sources: ViewRowSources) => boolean;
 }
 export interface AntiJoinDef {
     table: string;
-    on: [string, string];
-    where?: (joinRow: Row, baseRow: Row) => boolean;
+    on: JoinFieldLink | JoinLink[];
+    where?: (joinRow: Row, baseRow: Row, sources: ViewRowSources) => boolean;
 }
 export interface ViewDef {
     base: string;
+    baseAlias?: string;
     pkField?: string | string[];
     joins?: JoinDef[];
     antiJoins?: AntiJoinDef[];
-    derived?: Record<string, (row: Row) => any>;
+    select?: Record<string, string>;
+    derived?: Record<string, (row: Row, sources: ViewRowSources) => any>;
     derivedTypes?: Record<string, GenesisFieldType | Omit<FieldDef, 'name'>>;
     fields?: string[];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@genesislcap/mock-server",
-  "version": "15.53.0",
+  "version": "15.55.0",
   "description": "Reusable in-memory Genesis WebSocket protocol mock server for client automation/CI, without a JVM or database.",
   "type": "module",
   "main": "dist/index.js",

package/src/db/schema.ts

@@ -21,6 +21,7 @@ import type {
 import { RECORD_FIELDS, RECORD_ID, TIMESTAMP } from './identity.ts';
 import { deriveFields } from './metadata.ts';
 import type { Store } from './store.ts';
+import { planView } from './views.ts';
 
 export interface ResolvedField {
   name: string;
@@ -137,32 +138,47 @@ function viewOf(name: string, config: MockServerConfig, store: Store): ViewDef |
   return store.views.get(name) ?? config.views?.[name];
 }
 
-// A view over a declared base table: the base table's columns, each join's
-// selected columns typed from the joined table (nullable, since a base row
-// may have no match), and the derived fields typed from derivedTypes (or
+// A view over a declared base table: the base table's columns and its
+// `select` aliases, each join's selected columns typed from the joined table
+// (at any depth), and the derived fields typed from derivedTypes (or
 // inferred from the view's rows when not given) — narrowed to the view's
-// fields block when it has one.
+// fields block when it has one. A joined column keeps its own nullability
+// only when its join is reached from the base through INNER joins alone;
+// any other may find no match, so it is nullable (GSF's
+// transformOutputFields).
 function declaredViewFields(
   viewName: string,
   view: ViewDef,
   config: MockServerConfig,
   store: Store,
 ): ResolvedField[] {
+  const plan = planView(viewName, view);
   const fields = new Map<string, ResolvedField>();
-  for (const field of resolveSourceSchema(view.base, config, store).fields) {
-    fields.set(field.name, field);
+  const baseFields = resolveSourceSchema(view.base, config, store).fields;
+  for (const field of baseFields) fields.set(field.name, field);
+  const aliased = (
+    name: string,
+    source: ResolvedField | undefined,
+    nullable: boolean | undefined,
+  ): ResolvedField => {
+    const { title: _title, ...rest } = source ?? {
+      name,
+      type: 'STRING',
+      nullable: true,
+      generated: false,
+    };
+    return { ...rest, name, nullable: nullable ?? rest.nullable, generated: false };
+  };
+  for (const [name, sourceField] of Object.entries(view.select ?? {})) {
+    const source = baseFields.find((field) => field.name === sourceField);
+    fields.set(name, aliased(name, source, undefined));
   }
-  for (const join of view.joins ?? []) {
+  for (const join of plan.joins) {
     const joined = resolveSourceSchema(join.table, config, store).fields;
-    for (const [alias, sourceField] of Object.entries(join.select ?? {})) {
+    const nullable = join.alwaysMatched ? undefined : true;
+    for (const [name, sourceField] of Object.entries(join.def.select ?? {})) {
       const source = joined.find((field) => field.name === sourceField);
-      const { title: _title, ...rest } = source ?? {
-        name: alias,
-        type: 'STRING',
-        nullable: true,
-        generated: false,
-      };
-      fields.set(alias, { ...rest, name: alias, nullable: true, generated: false });
+      fields.set(name, aliased(name, source, nullable));
     }
   }
   const derivedNames = Object.keys(view.derived ?? {});
@@ -408,6 +424,7 @@ function sourceFieldNames(
   // An undeclared base: the view's own fields block is all that is known.
   if (!base) return view.fields;
   const names = new Set(base);
+  for (const alias of Object.keys(view.select ?? {})) names.add(alias);
   for (const join of view.joins ?? []) {
     for (const alias of Object.keys(join.select ?? {})) names.add(alias);
   }