ad64ba532f
Generate checked navigation query pairs from closed React contracts before package checking. Retain per-type subscriptions under the logical PresentationMount and resolve cold component metadata independently of code. Keep scoped occurrence membership and idempotent local preparation in the presentation library; copy directly through state contracts without reading other PresentationMounts' source associations. Preserve normal transaction creation, pending references, portal synchronization and detach. Exercise automatic object refs in Reader queries, imported fragments and structured/aggregate results. Add heterogeneous owner-index, live dependency, cold metadata, browser ownership and latency coverage. Document measured improvements, supported query limits and qualification evidence.
544 lines
22 KiB
TypeScript
544 lines
22 KiB
TypeScript
import { comparableValue } from "./structured.js";
|
|
import {
|
|
GraphQLBoolean,
|
|
GraphQLString,
|
|
GraphQLInt,
|
|
GraphQLScalarType,
|
|
GraphQLObjectType,
|
|
GraphQLInputObjectType,
|
|
GraphQLList,
|
|
GraphQLNonNull,
|
|
visit,
|
|
type GraphQLInputType,
|
|
type GraphQLOutputType,
|
|
type GraphQLInputFieldConfigMap,
|
|
type GraphQLFieldConfigMap,
|
|
type GraphQLEnumType,
|
|
type DocumentNode,
|
|
type SelectionSetNode,
|
|
type FragmentDefinitionNode,
|
|
} from "graphql";
|
|
import { createHash } from "node:crypto";
|
|
import {
|
|
valueType,
|
|
type ValueType,
|
|
type InterfaceRevision,
|
|
type InterfaceRevisionId,
|
|
type RelationshipInterfaceMember,
|
|
} from "../capability-model/types.js";
|
|
import {
|
|
aggregateType,
|
|
aggregateOperators,
|
|
queryKeyType,
|
|
type QueryRow,
|
|
type AggregateOperator,
|
|
} from "./relational.js";
|
|
import { QueryCompileError } from "./types.js";
|
|
|
|
export const rowKey = (row: QueryRow): string => JSON.stringify(row);
|
|
export const objectRow = (
|
|
interfaceRevisionId: InterfaceRevisionId,
|
|
membership?: { keyType?: "string" | "boolean" | "int64" },
|
|
): QueryRow => ({ kind: "object", interfaceRevisionId, ...(membership ? { membership } : {}) });
|
|
export type SchemaRowField = { kind: "leaf"; type: ValueType } | { kind: "row"; row: QueryRow; optional: boolean };
|
|
export interface RelationalSchemaEnvironment {
|
|
contracts: Map<InterfaceRevisionId, InterfaceRevision>;
|
|
target(member: RelationshipInterfaceMember): InterfaceRevisionId;
|
|
viewable(member: RelationshipInterfaceMember): boolean;
|
|
name(id: InterfaceRevisionId): string;
|
|
scalar(type: ValueType): GraphQLInputType & GraphQLOutputType;
|
|
comparison(type: ValueType): GraphQLInputObjectType;
|
|
valueOrder(type: ValueType): GraphQLInputType;
|
|
scalarTypes: Map<string, ValueType>;
|
|
direction: GraphQLEnumType;
|
|
cursor: GraphQLScalarType;
|
|
pageInfo: GraphQLObjectType;
|
|
}
|
|
|
|
export function relationalSchema(env: RelationalSchemaEnvironment, document?: DocumentNode) {
|
|
const requestedInterfaces = new Set<string>();
|
|
if (document)
|
|
visit(document, {
|
|
ObjectField(node) {
|
|
if (node.name.value !== "_camino" || node.value.kind !== "ObjectValue") return;
|
|
const qualified = node.value.fields.find((field) => field.name.value === "as");
|
|
if (qualified?.value.kind === "ObjectValue")
|
|
for (const field of qualified.value.fields) requestedInterfaces.add(field.name.value);
|
|
},
|
|
});
|
|
const outputCache = new Map<string, GraphQLObjectType>();
|
|
const inputCache = new Map<string, GraphQLInputObjectType>();
|
|
const referenceCache = new Map<string, GraphQLScalarType>();
|
|
const rowsets = new Map<string, QueryRow>();
|
|
const expansionPaths = new Map<string, Map<string, string[]>>();
|
|
const roles = new Map<
|
|
string,
|
|
{ kind: "rowset" | "aggregate" | "groups" | "keys" | "expand" | "relations"; row: QueryRow }
|
|
>();
|
|
const many = (member: RelationshipInterfaceMember) =>
|
|
member.cardinality === "many" || member.cardinality === "many-unique";
|
|
const relationRow = (member: RelationshipInterfaceMember) =>
|
|
objectRow(env.target(member), { keyType: member.keyType });
|
|
const relations = (row: QueryRow) =>
|
|
row.kind === "object"
|
|
? env.contracts
|
|
.get(row.interfaceRevisionId)!
|
|
.members.filter(
|
|
(member): member is RelationshipInterfaceMember =>
|
|
member.kind === "relationship" && !!member.queryRead && env.viewable(member),
|
|
)
|
|
: [];
|
|
const fields = (row: QueryRow): Map<string, SchemaRowField> => {
|
|
if (row.kind === "pair")
|
|
return new Map([
|
|
["source", { kind: "row", row: row.source, optional: false }],
|
|
["target", { kind: "row", row: row.target, optional: false }],
|
|
]);
|
|
return new Map(
|
|
env.contracts.get(row.interfaceRevisionId)!.members.flatMap((member): [string, SchemaRowField][] => {
|
|
if (member.kind === "operation" || member.kind === "module" || !member.queryRead) return [];
|
|
if (member.kind === "value") return [[member.displayName, { kind: "leaf", type: member.valueType }]];
|
|
if (!env.viewable(member)) return [];
|
|
if (many(member)) return [];
|
|
return [
|
|
[
|
|
member.displayName,
|
|
{ kind: "row", row: objectRow(env.target(member)), optional: member.cardinality === "optional-one" },
|
|
],
|
|
];
|
|
}),
|
|
);
|
|
};
|
|
const refs = (id: InterfaceRevisionId) => {
|
|
let result = referenceCache.get(id);
|
|
if (!result) {
|
|
result = new GraphQLScalarType({
|
|
name: `QxRef_${env.name(id)}`,
|
|
parseValue: (value) => value,
|
|
parseLiteral() {
|
|
throw new Error("Managed references must be supplied as typed variables");
|
|
},
|
|
});
|
|
referenceCache.set(id, result);
|
|
env.scalarTypes.set(result.name, valueType.interfaceRef(id));
|
|
}
|
|
return result;
|
|
};
|
|
const scalar = (type: ValueType): GraphQLInputType & GraphQLOutputType => {
|
|
if (type.kind === "optional") return scalar(type.value);
|
|
return type.kind === "object-ref" && type.expectation.kind === "interface"
|
|
? refs(type.expectation.interfaceRevisionId)
|
|
: env.scalar(type);
|
|
};
|
|
const leafFields = (row: QueryRow) => {
|
|
const result = new Map<string, ValueType>();
|
|
if (row.kind === "object") result.set("ref", valueType.interfaceRef(row.interfaceRevisionId));
|
|
if (row.kind === "pair" || row.membership) result.set("entry", valueType.string);
|
|
if (row.kind === "object" && row.membership?.keyType)
|
|
result.set(
|
|
"mapKey",
|
|
row.membership.keyType === "boolean"
|
|
? valueType.bool
|
|
: row.membership.keyType === "int64"
|
|
? valueType.int64
|
|
: valueType.string,
|
|
);
|
|
return result;
|
|
};
|
|
const typeName = (role: string, row: QueryRow, suffix = "") =>
|
|
`Qx${role}_${createHash("sha256")
|
|
.update(rowKey(row) + suffix)
|
|
.digest("hex")
|
|
.slice(0, 16)}`;
|
|
const out = (role: string, row: QueryRow, make: () => GraphQLFieldConfigMap<unknown, unknown>, suffix = "") => {
|
|
const key = typeName(role, row, suffix);
|
|
let result = outputCache.get(key);
|
|
if (!result) {
|
|
result = new GraphQLObjectType({ name: key, fields: make });
|
|
outputCache.set(key, result);
|
|
}
|
|
return result;
|
|
};
|
|
const inp = (role: string, row: QueryRow, make: () => GraphQLInputFieldConfigMap, suffix = "") => {
|
|
const key = typeName(role, row, suffix);
|
|
let result = inputCache.get(key);
|
|
if (!result) {
|
|
result = new GraphQLInputObjectType({ name: key, fields: make });
|
|
inputCache.set(key, result);
|
|
}
|
|
return result;
|
|
};
|
|
const compare = (type: ValueType) => {
|
|
const base = type.kind === "optional" ? type.value : type;
|
|
if (base.kind !== "object-ref") return env.comparison(type);
|
|
return inp(
|
|
"RefCompare",
|
|
objectRow(
|
|
base.expectation.kind === "interface"
|
|
? base.expectation.interfaceRevisionId
|
|
: (() => {
|
|
throw new Error("Expected interface reference");
|
|
})(),
|
|
),
|
|
() => ({ eq: { type: scalar(type) }, in: { type: new GraphQLList(new GraphQLNonNull(scalar(type))) } }),
|
|
);
|
|
};
|
|
// Recursive interface graphs are interned. Synthetic pair graphs are finite and document-driven.
|
|
const columns = (
|
|
row: QueryRow,
|
|
operator?: Exclude<AggregateOperator, "count">,
|
|
nullable = false,
|
|
): GraphQLObjectType =>
|
|
out(
|
|
"Columns",
|
|
row,
|
|
() => {
|
|
const result: GraphQLFieldConfigMap<unknown, unknown> = {};
|
|
for (const [name, field] of fields(row)) {
|
|
if (field.kind === "row")
|
|
result[name] = { type: new GraphQLNonNull(columns(field.row, operator, nullable || field.optional)) };
|
|
else {
|
|
let type = field.type;
|
|
if (operator) {
|
|
try {
|
|
type = aggregateType(operator, type);
|
|
} catch {
|
|
continue;
|
|
}
|
|
} else if (!queryKeyType(type)) continue;
|
|
result[name] = {
|
|
type:
|
|
type.kind === "optional" || (!operator && nullable) ? scalar(type) : new GraphQLNonNull(scalar(type)),
|
|
};
|
|
}
|
|
}
|
|
const metadata: GraphQLFieldConfigMap<unknown, unknown> = {};
|
|
for (const [name, type] of leafFields(row)) {
|
|
if (operator && operator !== "countPresent") continue;
|
|
const t = scalar(operator ? aggregateType(operator, type) : type);
|
|
metadata[name] = { type: !operator && nullable ? t : new GraphQLNonNull(t) };
|
|
}
|
|
if (Object.keys(metadata).length)
|
|
result._camino = {
|
|
type: new GraphQLNonNull(out("ColumnsMeta", row, () => metadata, `${operator}:${nullable}`)),
|
|
};
|
|
// A type may have no matching scalar at this node; a private schema sentinel
|
|
// keeps it valid while compiler validation forbids selecting that sentinel.
|
|
if (!Object.keys(result).length) result._unavailable = { type: GraphQLBoolean };
|
|
return result;
|
|
},
|
|
`${operator}:${nullable}`,
|
|
);
|
|
const aggregate = (row: QueryRow): GraphQLObjectType => {
|
|
const result = out("Aggregate", row, () =>
|
|
Object.fromEntries(
|
|
aggregateOperators.map((op) => [
|
|
op,
|
|
{ type: new GraphQLNonNull(op === "count" ? env.scalar(valueType.uint64) : columns(row, op)) },
|
|
]),
|
|
),
|
|
);
|
|
roles.set(result.name, { kind: "aggregate", row });
|
|
return result;
|
|
};
|
|
const keys = (row: QueryRow): GraphQLInputObjectType =>
|
|
inp("Keys", row, () => {
|
|
const result: GraphQLInputFieldConfigMap = {};
|
|
for (const [name, field] of fields(row)) {
|
|
if (field.kind === "row") result[name] = { type: keys(field.row) };
|
|
else if (queryKeyType(field.type)) result[name] = { type: GraphQLBoolean };
|
|
}
|
|
const meta = Object.fromEntries([...leafFields(row)].map(([name]) => [name, { type: GraphQLBoolean }]));
|
|
if (Object.keys(meta).length) result._camino = { type: inp("KeyMeta", row, () => meta) };
|
|
return result;
|
|
});
|
|
const comparisons = (
|
|
row: QueryRow,
|
|
operator?: Exclude<AggregateOperator, "count">,
|
|
ordering = false,
|
|
): GraphQLInputObjectType =>
|
|
inp(
|
|
"Expressions",
|
|
row,
|
|
() => {
|
|
const result: GraphQLInputFieldConfigMap = {};
|
|
for (const [name, field] of fields(row)) {
|
|
if (field.kind === "row") result[name] = { type: comparisons(field.row, operator, ordering) };
|
|
else {
|
|
let type = field.type;
|
|
if (operator) {
|
|
try {
|
|
type = aggregateType(operator, type);
|
|
} catch {
|
|
continue;
|
|
}
|
|
}
|
|
if (!comparableValue(type, ordering)) continue;
|
|
result[name] = { type: ordering ? env.valueOrder(type) : compare(type) };
|
|
}
|
|
}
|
|
const meta: GraphQLInputFieldConfigMap = {};
|
|
for (const [name, type] of leafFields(row))
|
|
if (!operator || operator === "countPresent")
|
|
meta[name] = { type: ordering ? env.direction : compare(operator ? aggregateType(operator, type) : type) };
|
|
if (Object.keys(meta).length)
|
|
result._camino = { type: inp("ExpressionMeta", row, () => meta, `${operator}:${ordering}`) };
|
|
if (!Object.keys(result).length) result._unavailable = { type: GraphQLBoolean };
|
|
return result;
|
|
},
|
|
`${operator}:${ordering}`,
|
|
);
|
|
const having = (row: QueryRow, ordering = false): GraphQLInputObjectType =>
|
|
inp(
|
|
"Having",
|
|
row,
|
|
() => {
|
|
const result: GraphQLInputFieldConfigMap = { group: { type: comparisons(row, undefined, ordering) } };
|
|
for (const op of aggregateOperators)
|
|
result[op] = {
|
|
type:
|
|
op === "count" ? (ordering ? env.direction : compare(valueType.uint64)) : comparisons(row, op, ordering),
|
|
};
|
|
if (!ordering)
|
|
Object.assign(result, {
|
|
and: { type: new GraphQLList(new GraphQLNonNull(having(row))) },
|
|
or: { type: new GraphQLList(new GraphQLNonNull(having(row))) },
|
|
not: { type: having(row) },
|
|
});
|
|
return result;
|
|
},
|
|
String(ordering),
|
|
);
|
|
const where = (row: QueryRow): GraphQLInputObjectType =>
|
|
inp("Where", row, () => {
|
|
const result: GraphQLInputFieldConfigMap = {
|
|
and: { type: new GraphQLList(new GraphQLNonNull(where(row))) },
|
|
or: { type: new GraphQLList(new GraphQLNonNull(where(row))) },
|
|
not: { type: where(row) },
|
|
};
|
|
for (const [name, field] of fields(row)) {
|
|
if (name in result) throw new QueryCompileError("QUERY_SCHEMA_NAME", `Reserved predicate name ${name}`);
|
|
if (row.kind === "object" && field.kind === "row") {
|
|
result[name] = {
|
|
type: compare(
|
|
valueType.interfaceRef(
|
|
field.row.kind === "object"
|
|
? field.row.interfaceRevisionId
|
|
: (() => {
|
|
throw new Error("Expected relationship object");
|
|
})(),
|
|
),
|
|
),
|
|
};
|
|
continue;
|
|
}
|
|
if (field.kind === "leaf" && !comparableValue(field.type)) continue;
|
|
result[name] = { type: field.kind === "row" ? where(field.row) : compare(field.type) };
|
|
}
|
|
result._camino = {
|
|
type: inp("WhereMeta", row, () => {
|
|
const meta: GraphQLInputFieldConfigMap = {};
|
|
if (row.kind === "object" && requestedInterfaces.size)
|
|
meta.as = {
|
|
type: inp("Interfaces", row, () =>
|
|
Object.fromEntries(
|
|
[...env.contracts.values()]
|
|
.filter((contract) => !contract.template && requestedInterfaces.has(env.name(contract.revisionId)))
|
|
.map((contract) => [
|
|
env.name(contract.revisionId),
|
|
{ type: where(objectRow(contract.revisionId)) },
|
|
]),
|
|
),
|
|
),
|
|
};
|
|
for (const [name, type] of leafFields(row)) meta[name] = { type: compare(type) };
|
|
const edges = relations(row);
|
|
if (edges.length)
|
|
meta.relations = {
|
|
type: inp("WhereRelations", row, () =>
|
|
Object.fromEntries(
|
|
edges.map((member) => {
|
|
const target = relationRow(member);
|
|
return [
|
|
member.displayName,
|
|
{
|
|
type: inp(
|
|
"RelationPredicate",
|
|
target,
|
|
(): GraphQLInputFieldConfigMap =>
|
|
many(member)
|
|
? {
|
|
some: { type: where(target) },
|
|
none: { type: where(target) },
|
|
aggregate: {
|
|
type: inp("ReductionPredicate", target, () => ({
|
|
where: { type: where(target) },
|
|
having: { type: new GraphQLNonNull(having(target)) },
|
|
})),
|
|
},
|
|
}
|
|
: { is: { type: where(target) }, isNull: { type: GraphQLBoolean } },
|
|
rowKey(row) + member.id,
|
|
),
|
|
},
|
|
];
|
|
}),
|
|
),
|
|
),
|
|
};
|
|
return meta;
|
|
}),
|
|
};
|
|
return result;
|
|
});
|
|
|
|
const fragments = new Map(
|
|
(document?.definitions ?? [])
|
|
.filter((d): d is FragmentDefinitionNode => d.kind === "FragmentDefinition")
|
|
.map((d) => [d.name.value, d]),
|
|
);
|
|
let visited = 0;
|
|
const selections = (set: SelectionSetNode, active: ReadonlySet<string> = new Set()): import("graphql").FieldNode[] =>
|
|
set.selections.flatMap((node) => {
|
|
if (++visited > 10000)
|
|
throw new QueryCompileError("QUERY_WORK_LIMIT", "Query schema discovery exceeds 10000 nodes");
|
|
if (node.kind === "Field") return [node];
|
|
if (node.kind === "FragmentSpread") {
|
|
if (active.has(node.name.value) || active.size >= 128)
|
|
throw new QueryCompileError("QUERY_VALIDATION", "Cyclic or excessively nested fragments");
|
|
const fragment = fragments.get(node.name.value);
|
|
return fragment ? selections(fragment.selectionSet, new Set([...active, node.name.value])) : [];
|
|
}
|
|
return [];
|
|
});
|
|
const discoverExpansion = (root: QueryRow, current: QueryRow, set: SelectionSetNode, path: string[] = []) => {
|
|
for (const node of selections(set)) {
|
|
if (!node.selectionSet) continue;
|
|
const member = relations(current).find((m) => m.displayName === node.name.value);
|
|
const next = [...path, node.name.value];
|
|
if (member && many(member)) {
|
|
const map = expansionPaths.get(rowKey(root)) ?? new Map();
|
|
map.set(next.join("."), next);
|
|
expansionPaths.set(rowKey(root), map);
|
|
discoverRows({ kind: "pair", source: root, target: relationRow(member) }, node.selectionSet);
|
|
} else {
|
|
const field = fields(current).get(node.name.value);
|
|
if (field?.kind === "row") discoverExpansion(root, field.row, node.selectionSet, next);
|
|
}
|
|
}
|
|
};
|
|
const discoverRows = (row: QueryRow, set: SelectionSetNode) => {
|
|
rowsets.set(rowKey(row), row);
|
|
if (rowsets.size > 256) throw new QueryCompileError("QUERY_WORK_LIMIT", "Query exceeds 256 row shapes");
|
|
for (const node of selections(set))
|
|
if (node.selectionSet) {
|
|
if (node.name.value === "expand") discoverExpansion(row, row, node.selectionSet);
|
|
else if (node.name.value === "filter" || node.name.value === "distinct") discoverRows(row, node.selectionSet);
|
|
}
|
|
};
|
|
const discoverObject = (row: QueryRow, set: SelectionSetNode) => {
|
|
for (const node of selections(set))
|
|
if (node.selectionSet) {
|
|
if (node.name.value === "_camino") {
|
|
for (const meta of selections(node.selectionSet))
|
|
if (meta.name.value === "relations" && meta.selectionSet)
|
|
for (const edge of selections(meta.selectionSet)) {
|
|
const member = relations(row).find((m) => m.displayName === edge.name.value);
|
|
if (member && many(member) && edge.selectionSet) discoverRows(relationRow(member), edge.selectionSet);
|
|
}
|
|
} else {
|
|
const member = relations(row).find((m) => m.displayName === node.name.value);
|
|
if (member) {
|
|
if (!many(member)) discoverObject(objectRow(env.target(member)), node.selectionSet);
|
|
else
|
|
for (const entries of selections(node.selectionSet))
|
|
if (entries.name.value === "entries" && entries.selectionSet)
|
|
for (const child of selections(entries.selectionSet))
|
|
if (child.name.value === "node" && child.selectionSet)
|
|
discoverObject(objectRow(env.target(member)), child.selectionSet);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
const discover = (root: InterfaceRevisionId) => {
|
|
for (const operation of document?.definitions ?? [])
|
|
if (operation.kind === "OperationDefinition")
|
|
for (const node of selections(operation.selectionSet))
|
|
if (node.name.value === "root" && node.selectionSet) discoverObject(objectRow(root), node.selectionSet);
|
|
};
|
|
const expand = (root: QueryRow, current: QueryRow, path: string[] = []): GraphQLObjectType =>
|
|
out(
|
|
"Expand",
|
|
current,
|
|
() => {
|
|
const result: GraphQLFieldConfigMap<unknown, unknown> = {};
|
|
const paths = [...(expansionPaths.get(rowKey(root))?.values() ?? [])].filter((p) =>
|
|
path.every((part, i) => p[i] === part),
|
|
);
|
|
for (const name of new Set(paths.map((p) => p[path.length]).filter((v): v is string => !!v))) {
|
|
const member = relations(current).find((m) => m.displayName === name);
|
|
if (member && many(member))
|
|
result[name] = {
|
|
type: new GraphQLNonNull(rowset({ kind: "pair", source: root, target: relationRow(member) })),
|
|
};
|
|
else {
|
|
const field = fields(current).get(name);
|
|
if (field?.kind === "row")
|
|
result[name] = { type: new GraphQLNonNull(expand(root, field.row, [...path, name])) };
|
|
}
|
|
}
|
|
if (!Object.keys(result).length) result._unavailable = { type: GraphQLBoolean };
|
|
return result;
|
|
},
|
|
rowKey(root) + JSON.stringify(path),
|
|
);
|
|
const rowset = (row: QueryRow): GraphQLObjectType => {
|
|
const result = out("Rows", row, () => {
|
|
const entry = out("GroupEntry", row, () => ({
|
|
key: { type: new GraphQLNonNull(GraphQLString) },
|
|
cursor: { type: env.cursor },
|
|
group: { type: new GraphQLNonNull(columns(row)) },
|
|
aggregate: { type: new GraphQLNonNull(aggregate(row)) },
|
|
}));
|
|
const connection = out("Groups", row, () => ({
|
|
entries: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(entry))) },
|
|
pageInfo: { type: new GraphQLNonNull(env.pageInfo) },
|
|
}));
|
|
roles.set(connection.name, { kind: "groups", row });
|
|
return {
|
|
filter: { type: new GraphQLNonNull(rowset(row)), args: { where: { type: new GraphQLNonNull(where(row)) } } },
|
|
distinct: { type: new GraphQLNonNull(rowset(row)), args: { by: { type: new GraphQLNonNull(keys(row)) } } },
|
|
expand: { type: new GraphQLNonNull(expand(row, row)) },
|
|
aggregate: { type: new GraphQLNonNull(aggregate(row)), args: { where: { type: where(row) } } },
|
|
groups: {
|
|
type: new GraphQLNonNull(connection),
|
|
args: {
|
|
by: { type: new GraphQLNonNull(keys(row)) },
|
|
where: { type: where(row) },
|
|
having: { type: having(row) },
|
|
orderBy: { type: new GraphQLList(new GraphQLNonNull(having(row, true))) },
|
|
first: { type: GraphQLInt },
|
|
all: { type: GraphQLInt },
|
|
after: { type: env.cursor },
|
|
},
|
|
},
|
|
};
|
|
});
|
|
roles.set(result.name, { kind: "rowset", row });
|
|
return result;
|
|
};
|
|
const helpers = (id: InterfaceRevisionId): GraphQLObjectType | undefined => {
|
|
const row = objectRow(id),
|
|
edges = relations(row).filter(many);
|
|
if (!edges.length) return undefined;
|
|
const result = out("Relations", row, () =>
|
|
Object.fromEntries(
|
|
edges.map((member) => [member.displayName, { type: new GraphQLNonNull(rowset(relationRow(member))) }]),
|
|
),
|
|
);
|
|
roles.set(result.name, { kind: "relations", row });
|
|
return result;
|
|
};
|
|
return { refs, fields, relations, relationRow, where, rowset, helpers, roles, discover, scalar, compare };
|
|
}
|