@kubun/graphql 0.10.1 → 0.12.0

package/lib/schema.js

@@ -1 +1,2484 @@
-import{AttachmentID as e,DocumentID as t,DocumentModelID as i,decodeID as n,PluginNodeID as s}from"@kubun/id";import{REFERENCE_PREFIX as l}from"@kubun/protocol";import{pascalCase as r}from"change-case";import{extendSchema as o,GraphQLBoolean as a,GraphQLEnumType as u,GraphQLFloat as c,GraphQLID as d,GraphQLInputObjectType as p,GraphQLInt as f,GraphQLInterfaceType as h,GraphQLList as y,GraphQLNonNull as m,GraphQLObjectType as _,GraphQLSchema as g,GraphQLString as b,isEnumType as w,isListType as v,isNonNullType as D,isObjectType as O,isScalarType as I,Kind as $,parse as j}from"graphql";import{connectionArgs as S,connectionDefinitions as F,mutationWithClientMutationId as M,nodeDefinitions as R}from"graphql-relay";import{GraphQLDateTimeISO as T,GraphQLDID as x,GraphQLDuration as A,GraphQLEmailAddress as L,GraphQLJSON as E,GraphQLJSONObject as k}from"graphql-scalars";import{GraphQLAttachmentID as q,GraphQLDocID as B}from"./identifiers.js";import{GraphQLURL as G}from"./scalars.js";import{getUniqueDocValue as N,validateAccessIdentifiers as P}from"./utils.js";function C(e){if(D(e))return C(e.ofType);if(v(e))return[];if(I(e))switch(e.name){case"String":case"ID":return"";case"Int":case"Float":return 0;case"Boolean":return!1;default:return null}if(w(e)){let t=e.getValues();return t[0]?.value??null}return{}}let V={date:b,time:b,"date-time":b,duration:A,email:L,uri:G},Q={attachmentid:q,did:x,docid:B};function H(e){return e.slice(l.length)}function K(e){return v(e)||D(e)&&v(e.ofType)}export function toDocumentModelID(e){return e instanceof i?e:i.fromString(e)}export function getGlobalID(e,t){let i=toDocumentModelID(e);return i.isLocal?i.toGlobal(toDocumentModelID(t)):i}export function toList(e){return new y(new m(e))}export function toOuputList(e){return new y(new m(e))}function U(e){return new p({name:`${e.name}ValueFilter`,isOneOf:!0,fields:{isNull:{type:a},equalTo:{type:e},notEqualTo:{type:e},in:{type:toList(e)},notIn:{type:toList(e)},lessThan:{type:e},lessThanOrEqualTo:{type:e},greaterThan:{type:e},greaterThanOrEqualTo:{type:e}}})}let z={AccountValueFilter:new p({name:"AccountValueFilter",isOneOf:!0,fields:{equalTo:{type:x},notEqualTo:{type:x},in:{type:toList(x)},notIn:{type:toList(x)}}}),BooleanValueFilter:new p({name:"BooleanValueFilter",isOneOf:!0,fields:{isNull:{type:a},equalTo:{type:a}}}),FloatValueFilter:U(c),IntValueFilter:U(f),StringValueFilter:U(b)},W={GraphQLBoolean:"BooleanValueFilter",GraphQLDID:"AccountValueFilter",GraphQLFloat:"FloatValueFilter",GraphQLInt:"IntValueFilter",GraphQLString:"StringValueFilter"},J=new p({name:"PatchSetOperation",fields:{path:{type:new m(b)},value:{type:E}}}),X=new p({name:"PatchRemoveOperation",fields:{path:{type:new m(b)}}}),Y=new p({name:"PatchDestinationOperation",fields:{from:{type:new m(b)},path:{type:new m(b)}}});export const PatchOperation=new p({name:"PatchOperation",isOneOf:!0,fields:{add:{type:J},set:{type:J},remove:{type:X},replace:{type:J},copy:{type:Y},move:{type:Y}}});let Z=new u({name:"OrderByDirection",values:{ASC:{value:"asc"},DESC:{value:"desc"}}}),ee=new _({name:"AccessRule",fields:{level:{type:new m(b)},allowedDIDs:{type:new y(new m(b))},allowedCircles:{type:new y(new m(b))},allowedGroups:{type:new y(new m(b))}}}),et=new _({name:"AccessPermissions",fields:{read:{type:ee},write:{type:ee}}}),ei=new _({name:"ModelAccessDefaults",fields:()=>({ownerDID:{type:new m(b)},modelID:{type:new m(d)},permissions:{type:new m(et)}})});export class SchemaBuilder{_aliases;_aliasToModelID;_aggregateNumericByModel={};_groupKeyNumericByModel={};_definitions;_implemented={};_includedModelIDs;_includeInterfaceDependencies;_includeMutations;_includeRelationDependencies;_includeSubscriptions;_inputObjects={...z,PatchOperation};_mutations={};_nodeModelIDs;_onlyModels;_record;_references={};_relationsTo={};_extensionSDL;_extensionResolvers;_stubExtensionResolvers;_pluginNodeResolvers={};_subscriptions={};_types={OrderByDirection:Z};constructor(e){for(let[t,i]of(this._record=e.record,this._onlyModels=e.onlyModels??null,this._includeInterfaceDependencies=e.includeInterfaceDependencies??!0,this._includeRelationDependencies=e.includeRelationDependencies??!0,this._includeMutations=e.includeMutations??!0,this._includeSubscriptions=e.includeSubscriptions??!0,this._extensionSDL=e.extensionSDL,this._extensionResolvers=e.extensionResolvers,this._stubExtensionResolvers=e.stubExtensionResolvers??!1,this._aliasToModelID=e.aliases??{},this._aliases={},Object.entries(this._aliasToModelID)))this._aliases[i]=t;for(let[t,i]of Object.entries(e.record))if(null==this._aliases[t]){let e=r(i.name);this._aliases[t]=e,this._aliasToModelID[e]??=t}this._includedModelIDs=this._resolveModelIDsToInclude();let t={};for(let[n,s]of Object.entries(e.record)){let e=i.fromString(n);for(let i of(Object.assign(this._references,s.schema.$defs??{}),s.interfaces)){let s=getGlobalID(i,e).toString();t[s]??=new Set,t[s].add(n)}for(let[t,i]of Object.entries(s.fieldsMeta))if("document"===i.type&&null!=i.model){let l=H(s.schema.properties[t]?.$ref),r="array"===this._getReferenceSchema(l).type,o=getGlobalID(i.model,e).toString();this._relationsTo[o]??={},this._relationsTo[o][t]??=[],this._relationsTo[o][t].push({model:n,isList:r})}}let n=new Set;for(let e of Object.keys(t)){let i=new Set;for(let s of(!function e(t,i,n){let s=i[n];if(null==s)throw Error(`Interface ${n} not found in record`);for(let n of s)null!=i[n]?e(t,i,n):t.add(n)}(i,t,e),0!==i.size&&(this._implemented[e]=Array.from(i)),i))n.add(s)}this._nodeModelIDs=Array.from(n)}_resolveModelIdentifier(e){if(null!=this._record[e])return e;let t=this._aliasToModelID[e];if(null!=t&&null!=this._record[t])return t;throw Error(`Model identifier "${e}" not found. Must be a valid model ID or alias.`)}_resolveModelIDsToInclude(){if(null==this._onlyModels||0===this._onlyModels.length)return new Set(Object.keys(this._record));let e=new Set;for(let t of this._onlyModels){let i=this._resolveModelIdentifier(t);e.add(i)}if(!this._includeInterfaceDependencies&&!this._includeRelationDependencies)return e;let t=Array.from(e),i=new Set;for(;t.length>0;){let n=t.pop();if(null==n||i.has(n))continue;i.add(n);let s=this._record[n];if(null!=s){if(this._includeInterfaceDependencies)for(let i of s.interfaces){let s=getGlobalID(i,n).toString();e.has(s)||(e.add(s),t.push(s))}if(this._includeRelationDependencies){for(let i of Object.values(s.fieldsMeta))if("document"===i.type&&null!=i.model&&null!==i.model){let s=getGlobalID(i.model,n).toString();e.has(s)||(e.add(s),t.push(s))}}}}return e}getModelIDs(e){return null===e?this._nodeModelIDs:this._implemented[e]??[e]}build(){let e=this._buildSharedDefinitions();this._definitions=e;let t={nodes:e.nodesField,...e.queryFields};for(let e of this._includedModelIDs){this._buildDocument(e);let i=this._aliases[e],n={type:this._inputObjects[`${e}-filter`]};t[`all${i}`]={type:this._types[`${e}-connection`],args:{...S,filter:n,orderBy:{type:toList(this._inputObjects[`${e}-order`])},search:{type:b}},resolve:async(t,i,n)=>await n.resolveConnection(this.getModelIDs(e),i)}}let i=[...this._includedModelIDs][0];if(null!=i){let n=this._types[`${i}-connection`].getFields().pageInfo.type,s=new _({name:"SearchResultEdge",fields:()=>({cursor:{type:new m(b)},node:{type:new m(e.nodeInterface)},rank:{type:new m(c)}})}),l=new _({name:"SearchResultConnection",fields:()=>({edges:{type:new m(new y(new m(s)))},pageInfo:{type:n}})});t.search={type:new m(l),args:{query:{type:new m(b)},models:{type:new y(new m(b))},first:{type:f},after:{type:b}},resolve:async(e,t,i)=>{let{query:n,models:s,first:l}=t;if(""===n.trim())throw Error("Search query must not be empty");let r=s?s.map(e=>this._aliasToModelID[e]??e):[...this._includedModelIDs],o=await i.searchDocuments(n,r,l??20),a=o.map(e=>e.documentID),u=[...new Set(o.map(e=>e.modelID))],c=new Map((a.length>0?await i.resolveList(u,a):[]).map(e=>[e.id,e])),d=[];for(let e of o){let t=c.get(e.documentID);null!=t&&d.push({cursor:String(d.length),node:t,rank:Math.abs(e.rank)})}return{edges:d,pageInfo:{hasNextPage:!1,hasPreviousPage:!1,startCursor:d.length>0?d[0].cursor:null,endCursor:d.length>0?d[d.length-1].cursor:null}}}}}if(this._includeMutations){this._mutations.setModelAccessDefaults={type:ei,args:{modelID:{type:new m(d)},permissionType:{type:new m(b)},accessLevel:{type:new m(b)},allowedDIDs:{type:toList(b)},allowedCircles:{type:toList(b)},allowedGroups:{type:toList(b)}},resolve:async(e,t,i)=>{let n=t.allowedDIDs??null,s=t.allowedCircles??null,l=t.allowedGroups??null;return P({allowedDIDs:n,allowedCircles:s,allowedGroups:l}),await i.executeSetModelAccessDefaults({modelID:t.modelID,permissionType:t.permissionType,accessLevel:t.accessLevel,allowedDIDs:n,allowedCircles:s,allowedGroups:l})}},this._mutations.removeModelAccessDefaults={type:a,args:{modelID:{type:new m(d)},permissionTypes:{type:new m(toList(b))}},resolve:async(e,t,i)=>(await i.executeRemoveModelAccessDefaults(t.modelID,t.permissionTypes),!0)},this._mutations.setDocumentAccessOverride={type:e.documentInterface,args:{documentID:{type:new m(d)},permissionType:{type:new m(b)},accessLevel:{type:new m(b)},allowedDIDs:{type:toList(b)},allowedCircles:{type:toList(b)},allowedGroups:{type:toList(b)}},resolve:async(e,t,i)=>{let n=t.allowedDIDs??null,s=t.allowedCircles??null,l=t.allowedGroups??null;return P({allowedDIDs:n,allowedCircles:s,allowedGroups:l}),await i.executeSetDocumentAccessOverride({documentID:t.documentID,permissionType:t.permissionType,accessLevel:t.accessLevel,allowedDIDs:n,allowedCircles:s,allowedGroups:l})}},this._mutations.removeDocumentAccessOverride={type:a,args:{documentID:{type:new m(d)},permissionTypes:{type:new m(toList(b))}},resolve:async(e,t,i)=>(await i.executeRemoveDocumentAccessOverride(t.documentID,t.permissionTypes),!0)};let t=new _({name:"BeginTransactionPayload",fields:{transactionID:{type:new m(d)}}}),i=new _({name:"CommitTransactionPayload",fields:{success:{type:new m(a)}}}),n=new _({name:"RollbackTransactionPayload",fields:{success:{type:new m(a)}}});this._mutations.beginTransaction={type:new m(t),args:{},resolve:(e,t,i)=>i.beginTransaction()},this._mutations.commitTransaction={type:new m(i),args:{transactionID:{type:new m(d)}},resolve:async(e,t,i)=>await i.commitTransaction(t.transactionID)},this._mutations.rollbackTransaction={type:new m(n),args:{transactionID:{type:new m(d)}},resolve:(e,t,i)=>i.rollbackTransaction(t.transactionID)}}let n={query:new _({name:"Query",fields:t}),types:[G,x,T]};this._includeMutations&&(n.mutation=new _({name:"Mutation",fields:this._mutations})),this._includeSubscriptions&&(n.subscription=new _({name:"Subscription",fields:()=>{let t={...this._subscriptions};if(this._includeSubscriptions)for(let[i,n]of(t.documentChanged={type:new m(e.documentInterface),args:{id:{type:new m(d)}},resolve:e=>e,subscribe:(e,t,i)=>i.subscribeToDocumentChanged(t.id)},t.documentRemoved={type:new m(d),resolve:e=>e,subscribe:(e,t,i)=>i.subscribeToDocumentRemoved()},Object.entries(this._record))){if(!this._includedModelIDs.has(i))continue;let e=this._aliases[i];for(let s of(t[`new${e}Created`]={type:new m(this._types[i]),args:{owner:{type:d}},resolve:e=>e,subscribe:(e,t,n)=>n.subscribeToDocumentCreated(this.getModelIDs(i),t.owner??void 0)},n.interfaces??[])){let e=getGlobalID(s,i).toString();for(let[i,n]of Object.entries(this._relationsTo[e]??{}))for(let s of n)this._buildRelationSubscriptions(t,e,i,s)}for(let[e,n]of Object.entries(this._relationsTo[i]??{}))for(let s of n)this._includedModelIDs.has(s.model)&&this._buildRelationSubscriptions(t,i,e,s)}return t}}));let s=new g(n);if(null!=this._extensionSDL){let e=new Set(Object.keys(s.getTypeMap()));s=o(s,j(this._extensionSDL)),this._stubExtensionResolvers&&this.#e(s,e)}return null!=this._extensionResolvers&&this.#t(s,this._extensionResolvers),s}#t(e,t){let i=e.getQueryType();if(null!=i&&null!=t.queryFields){let e=i.getFields();for(let[i,n]of Object.entries(t.queryFields)){if(null==e[i])throw Error(`Extension resolver for query field "${i}" has no matching field in SDL`);e[i].resolve=n}}let n=e.getMutationType();if(null!=n&&null!=t.mutationFields){let e=n.getFields();for(let[i,n]of Object.entries(t.mutationFields)){if(null==e[i])throw Error(`Extension resolver for mutation field "${i}" has no matching field in SDL`);e[i].resolve=n}}let s=e.getSubscriptionType();if(null!=s&&null!=t.subscriptionFields){let e=s.getFields();for(let[i,n]of Object.entries(t.subscriptionFields)){if(null==e[i])throw Error(`Extension resolver for subscription field "${i}" has no matching field in SDL`);e[i].resolve=n.resolve,e[i].subscribe=n.subscribe}}if(null!=t.typeFields)for(let[i,n]of Object.entries(t.typeFields)){let t=e.getType(i);if(null==t)throw Error(`Extension resolver references type "${i}" which does not exist in the schema`);if(!O(t))throw Error(`Extension resolver references type "${i}" which is not an object type`);let s=t.getFields();for(let[e,t]of Object.entries(n)){if(null==s[e])throw Error(`Extension resolver for field "${e}" on type "${i}" has no matching field in SDL`);s[e].resolve=t}}if(null!=t.nodeResolvers)for(let[e,i]of Object.entries(t.nodeResolvers))this._pluginNodeResolvers[e]=i}#e(e,t){for(let t of[e.getQueryType(),e.getMutationType()])if(null!=t)for(let e of Object.values(t.getFields()))null==e.resolve&&(e.resolve=()=>C(e.type));for(let[i,n]of Object.entries(e.getTypeMap()))if(!t.has(i)&&O(n)){for(let e of Object.values(n.getFields()))if(null==e.resolve){let t=e.type;e.resolve=i=>i[e.name]??C(t)}}}_getDefinitions(){if(null==this._definitions)throw Error("Definitions must be initialized");return this._definitions}_getReference(e,t){let i=H(e),n=this._types[i];if(null!=n)return n;let s=this._getReferenceSchema(i);return this._buildReference(i,s,t)}_getReferenceSchema(e){let t=this._references[e];if(null==t)throw Error(`Could not find reference: ${e}`);return t}_getReferenceInput(e,t,i=""){let n=H(e),s=this._getReferenceSchema(n);if("array"===s.type)return new y(new m(this._getReferenceInput(s.items.$ref,!1,s.title)));if("object"===s.type){if(s.additionalProperties)return k;let e=t?`${n}-partial`:n,l=this._inputObjects[e];if(null!=l)return l;let o={};for(let[e,i]of Object.entries(s.properties)){let n=this._getReferenceInput(i.$ref,t,s.title);o[e]={type:t||!s.required.includes(e)?n:new m(n)}}let a=this._aliases[n]??r(i+s.title),u=new p({name:t?`Partial${a}Input`:`${a}Input`,fields:o});return this._inputObjects[e]=u,u}return this._buildScalar(n,s,i)}_buildSharedDefinitions(){let i=R(async(i,l)=>{if(i.startsWith("did:"))return i;let r=n(i);if(r instanceof e)return r;if(r instanceof t)return await l.loadDocument(i);if(r instanceof s){let e=this._pluginNodeResolvers[r.typeName];if(null==e)throw Error(`No node resolver registered for plugin type "${r.typeName}"`);let t=await e.resolve(r.localID,l);if(null==t)throw Error(`Node resolver for "${r.typeName}" returned null for localID "${r.localID}"`);return{...t,__typename:r.typeName}}throw Error(`Unsupported node ID: ${i}`)},t=>{if("string"==typeof t)return"AccountNode";if(t instanceof e)return"AttachmentNode";if(null!=t&&"object"==typeof t&&"model"in t)return this._aliases[t.model];if(null!=t&&"object"==typeof t&&"__typename"in t)return t.__typename;throw Error("Unknown node type")}),l=new _({name:"AccountNode",interfaces:[i.nodeInterface],fields:()=>{let e={id:{type:new m(d),description:"Globally unique identifier of the account (DID string)",resolve:e=>e},isViewer:{type:new m(a),description:"Whether the authenticated request issuer is this account or not",resolve:(e,t,i)=>i.getViewer()===e}};for(let[i,n]of Object.entries(this._record))if(this._includedModelIDs.has(i))switch(n.behavior){case"interface":continue;case"default":{let t=this._aliases[i];e[`own${t}Connection`]={type:this._types[`${i}-connection`],args:{...S,filter:{type:this._inputObjects[`${i}-filter`]},orderBy:{type:toList(this._inputObjects[`${i}-order`])}},resolve:async(e,t,n)=>await n.resolveConnection(this.getModelIDs(i),{...t,owner:e})};break}case"unique":{let s=this._aliases[i];e[`own${s}`]={type:this._types[i],args:n.uniqueFields.length?{with:{type:new m(this._buildSetInputObjectType(i,n.uniqueFields))}}:{},resolve:async(e,s,l)=>{let r=N(n.uniqueFields,s.with),o=t.create(i,e,r);return await l.loadDocument(o.toString())}}}}return e}}),r=new _({name:"AttachmentNode",interfaces:[i.nodeInterface],fields:{id:{type:new m(d),resolve:e=>e.toString()},contentLength:{type:new m(f)},mimeType:{type:new m(b)}}}),o={id:{type:new m(d)},model:{type:new m(b)},owner:{type:new m(l)},createdAt:{type:new m(T)},updatedAt:{type:T},accessPermissions:{type:et,resolve:e=>e.data?.accessPermissions??null}},u=new h({name:"DocumentNode",interfaces:[i.nodeInterface],fields:o,resolveType:e=>this._aliases[e.model]}),c={node:i.nodeField,viewer:{type:l,description:"Account issuing the request, if authenticated",resolve:(e,t,i)=>i.getViewer()}};return{...i,accountObject:l,attachmentObject:r,documentInterface:u,documentNodeFields:o,queryFields:c}}_buildDocument(e){if(null!=this._types[e])return this._types[e];let t=this._record[e];if(null==t)throw Error(`Could not find model id: ${e}`);let i=this._getDefinitions();this._aliases[e]??=r(t.name);let n=this._aliases[e],s={name:n,interfaces:()=>[i.documentInterface,i.nodeInterface].concat(t.interfaces.map(t=>this._types[getGlobalID(t,e).toString()]).filter(e=>null!=e)),fields:()=>this._buildDocumentFields(e,t,n)},l="interface"===t.behavior,o=l?new h({...s,resolveType:e=>this._aliases[e.model]}):new _(s),a=this._buildAggregate(e,t,n),u=this._buildGroupedAggregate(e,t,n),{connectionType:c,edgeType:p}=F({nodeType:o,connectionFields:()=>{let t={aggregates:{type:a,resolve:async(t,i,n,s)=>{let l=t.aggregateScope,{count:r,aggregates:o}=this._buildAggregateRequest(e,s);return await n.resolveAggregate(l.modelIDs,{filter:l.filter,owner:l.owner,catalogID:l.catalogID,count:r,aggregates:o})}}};return null!=u&&(t.groupedAggregates={type:new m(toOuputList(u)),args:{groupBy:{type:new m(toList(this._inputObjects[`${e}-group-by`]))},having:{type:this._inputObjects[`${e}-having`]},orderBy:{type:toList(this._inputObjects[`${e}-group-order`])},limit:{type:f}},resolve:async(t,i,n,s)=>{let l=t.aggregateScope,{count:r,aggregates:o}=this._buildGroupedAggregateRequest(e,s),a=(i.groupBy??[]).map(e=>({keys:[e]})),u=this._buildGroupOrderBy(e,i.orderBy);return await n.resolveGroupedAggregate(l.modelIDs,{filter:l.filter,owner:l.owner,catalogID:l.catalogID,count:r,aggregates:o,groupBy:a,having:i.having,orderBy:u.length>0?u:void 0,limit:i.limit??void 0})}}),t}});return this._types[e]=o,this._types[`${e}-connection`]=c,this._types[`${e}-edge`]=p,this._buildDocumentDataObject(e,t,n),this._buildDocumentInput(e,t),this._buildObjectFilterInput(e,t.schema,n,!0),this._buildObjectOrderByInput(e,t.schema,n,!0),!l&&this._includeMutations&&("default"===t.behavior?this._mutations[`create${n}`]=M({name:`Create${n}`,inputFields:()=>({data:{type:new m(this._inputObjects[e])},transactionID:{type:d}}),outputFields:()=>({...i.queryFields,document:{type:this._types[e]}}),mutateAndGetPayload:async(t,i,n)=>({document:await i.executeCreateMutation({modelID:e,data:t.data,info:n,transactionID:t.transactionID})})}):"unique"===t.behavior&&(this._mutations[`set${n}`]=M({name:`Set${n}`,inputFields:()=>({data:{type:new m(this._inputObjects[e])},transactionID:{type:d}}),outputFields:()=>({...i.queryFields,document:{type:this._types[e]}}),mutateAndGetPayload:async(i,n,s)=>{let l=N(t.uniqueFields,i.data);return{document:await n.executeSetMutation({modelID:e,unique:l,data:i.data,info:s,transactionID:i.transactionID})}}})),this._mutations[`update${n}`]=M({name:`Update${n}`,inputFields:()=>({id:{type:new m(d)},patch:{type:new m(toList(PatchOperation))},from:{type:this._inputObjects[`${e}-update`]},transactionID:{type:d}}),outputFields:()=>({...i.queryFields,document:{type:this._types[e]}}),mutateAndGetPayload:async(e,t,i)=>({document:await t.executeUpdateMutation({input:e,info:i,transactionID:e.transactionID})})}),this._mutations[`remove${n}`]=M({name:`Remove${n}`,inputFields:()=>({id:{type:new m(d)},transactionID:{type:d}}),outputFields:()=>({...i.queryFields,id:{type:new m(d)}}),mutateAndGetPayload:async(e,t,i)=>(await t.executeRemoveMutation({id:e.id,info:i,transactionID:e.transactionID}),{id:e.id})})),o}_buildAggregate(e,t,i){let n=this._types[`${e}-aggregate`];if(null!=n)return n;let s={},l={},r=new Map;for(let[e,i]of Object.entries(t.schema.properties??{})){let t=i.$ref;if(null==t)continue;let n=H(t),o=this._getReferenceSchema(n);if("object"===o.type||"array"===o.type)continue;let a=this._buildScalar(n,o),u=a===f||a===c,d=a===b;u&&(s[e]={type:a}),(u||d)&&(l[e]={type:a},r.set(e,u))}this._aggregateNumericByModel[e]=r;let o=Object.keys(s),a={count:{type:new m(f),resolve:e=>e.count??0}};if(o.length>0){let t=new _({name:`${i}SumFields`,fields:s}),n={};for(let e of o)n[e]={type:c};let l=new _({name:`${i}AvgFields`,fields:n});this._types[`${e}-aggregate-sum`]=t,this._types[`${e}-aggregate-avg`]=l,a.sum={type:t,resolve:e=>e.sum??null},a.average={type:l,resolve:e=>e.average??null}}if(Object.keys(l).length>0){let t=new _({name:`${i}MinMaxFields`,fields:l});this._types[`${e}-aggregate-min-max`]=t,a.min={type:t,resolve:e=>e.min??null},a.max={type:t,resolve:e=>e.max??null}}let u=new _({name:`${i}Aggregate`,fields:a});return this._types[`${e}-aggregate`]=u,u}_buildGroupedAggregate(e,t,i){let n=this._types[`${e}-grouped-aggregate`];if(null!=n)return n;let s=new Map,l=new Map;for(let[e,i]of Object.entries(t.schema.properties??{})){let t=i.$ref;if(null==t)continue;let n=H(t),r=this._getReferenceSchema(n);if("object"===r.type||"array"===r.type)continue;let o=this._buildScalar(n,r);s.set(e,o),l.set(e,o===f||o===c)}if(this._groupKeyNumericByModel[e]=l,0===s.size)return null;let r=this._types[`${e}-aggregate-sum`],o=this._types[`${e}-aggregate-avg`],a=this._types[`${e}-aggregate-min-max`],d={};for(let e of s.keys())d[e]={value:e};let h=new u({name:`${i}GroupBy`,values:d});this._types[`${e}-group-by`]=h,this._inputObjects[`${e}-group-by`]=h;let y={};for(let[e,t]of s)y[e]={type:t};let g=new _({name:`${i}GroupKeys`,fields:y});this._types[`${e}-group-keys`]=g;let b={keys:{type:new m(g),resolve:e=>e.keys},count:{type:new m(f),resolve:e=>e.count??0}};null!=r&&null!=o&&(b.sum={type:r,resolve:e=>e.sum??null},b.average={type:o,resolve:e=>e.average??null}),null!=a&&(b.min={type:a,resolve:e=>e.min??null},b.max={type:a,resolve:e=>e.max??null});let w=new _({name:`${i}GroupedAggregate`,fields:b});this._types[`${e}-grouped-aggregate`]=w;let v=e=>this._inputObjects[`${e.name}ValueFilter`],D={count:{type:this._inputObjects.IntValueFilter}};if(null!=r&&null!=o){let t={},n={};for(let[e,i]of Object.entries(r.getFields()))t[e]={type:v(i.type)},n[e]={type:this._inputObjects.FloatValueFilter};let s=new p({name:`${i}HavingSum`,fields:t}),l=new p({name:`${i}HavingAverage`,fields:n});this._inputObjects[`${e}-having-sum`]=s,this._inputObjects[`${e}-having-average`]=l,D.sum={type:s},D.average={type:l}}if(null!=a){let t={},n={};for(let[e,i]of Object.entries(a.getFields()))t[e]={type:v(i.type)},n[e]={type:v(i.type)};let s=new p({name:`${i}HavingMin`,fields:t}),l=new p({name:`${i}HavingMax`,fields:n});this._inputObjects[`${e}-having-min`]=s,this._inputObjects[`${e}-having-max`]=l,D.min={type:s},D.max={type:l}}let O=new p({name:`${i}Having`,fields:D});this._inputObjects[`${e}-having`]=O;let I=(e,t)=>{let i={};for(let e of t)i[e]={type:Z};return new p({name:e,fields:i})},$=I(`${i}GroupKeysOrderBy`,s.keys());this._inputObjects[`${e}-group-keys-order`]=$;let j={keys:{type:$},count:{type:Z}};if(null!=r&&null!=o){let t=I(`${i}SumFieldsOrderBy`,Object.keys(r.getFields())),n=I(`${i}AvgFieldsOrderBy`,Object.keys(o.getFields()));this._inputObjects[`${e}-sum-order`]=t,this._inputObjects[`${e}-avg-order`]=n,j.sum={type:t},j.average={type:n}}if(null!=a){let t=I(`${i}MinFieldsOrderBy`,Object.keys(a.getFields())),n=I(`${i}MaxFieldsOrderBy`,Object.keys(a.getFields()));this._inputObjects[`${e}-min-order`]=t,this._inputObjects[`${e}-max-order`]=n,j.min={type:t},j.max={type:n}}let S=new p({name:`${i}GroupOrderBy`,fields:j});return this._inputObjects[`${e}-group-order`]=S,w}_buildAggregateRequest(e,t){let i=this._aggregateNumericByModel[e]??new Map,n=["sum","average","min","max"],s=!1,l=[];for(let e of t.fieldNodes){let r=e.selectionSet?.selections??[];for(let e of this._expandFieldSelections(r,t,new Set)){let r=e.name.value;if("count"===r){s=!0;continue}if(!n.includes(r))continue;let o=e.selectionSet?.selections??[];for(let e of this._expandFieldSelections(o,t,new Set)){let t=e.name.value;l.push({op:r,keys:[t],numeric:i.get(t)??!1})}}}return{count:s,aggregates:l}}_buildGroupedAggregateRequest(e,t){let i=this._aggregateNumericByModel[e]??new Map,n=["sum","average","min","max"],s=!1,l=[];for(let e of t.fieldNodes){let r=e.selectionSet?.selections??[];for(let e of this._expandFieldSelections(r,t,new Set)){let r=e.name.value;if("count"===r){s=!0;continue}if("keys"===r||!n.includes(r))continue;let o=e.selectionSet?.selections??[];for(let e of this._expandFieldSelections(o,t,new Set)){let t=e.name.value;l.push({op:r,keys:[t],numeric:i.get(t)??!1})}}}return{count:s,aggregates:l}}_buildGroupOrderBy(e,t){if(null==t)return[];let i=this._aggregateNumericByModel[e]??new Map,n=this._groupKeyNumericByModel[e]??new Map,s=[];for(let e of t){for(let[t,i]of(null!=e.count&&s.push({path:["count"],direction:e.count,numeric:!0}),Object.entries(e.keys??{})))s.push({path:["keys",t],direction:i,numeric:n.get(t)??!1});for(let[t,n]of Object.entries(e.sum??{}))s.push({path:["sum",t],direction:n,numeric:i.get(t)??!1});for(let[t,i]of Object.entries(e.average??{}))s.push({path:["average",t],direction:i,numeric:!0});for(let[t,n]of Object.entries(e.min??{}))s.push({path:["min",t],direction:n,numeric:i.get(t)??!1});for(let[t,n]of Object.entries(e.max??{}))s.push({path:["max",t],direction:n,numeric:i.get(t)??!1})}return s}*_expandFieldSelections(e,t,i){for(let n of e)switch(n.kind){case $.FIELD:yield n;break;case $.INLINE_FRAGMENT:yield*this._expandFieldSelections(n.selectionSet.selections,t,i);break;case $.FRAGMENT_SPREAD:{let e=n.name.value;if(i.has(e))break;let s=t.fragments[e];if(null==s)break;i.add(e),yield*this._expandFieldSelections(s.selectionSet.selections,t,i)}}}_buildDocumentFields(t,i,n){let s=this._buildDocumentDataObject(t,i,n),l=this._getDefinitions(),r={...l.documentNodeFields,data:{type:new m(s)}};for(let[n,o]of Object.entries(s.getFields())){let s=i.fieldsMeta[n];if(null!=s)switch(s.type){case"account":K(o.type)?r[`${n}Accounts`]={type:new m(toOuputList(l.accountObject)),resolve:e=>e.data?.[n]??[]}:r[`${n}Account`]={type:l.accountObject,resolve:e=>e.data?.[n]??null};break;case"attachment":K(o.type)?r[`${n}Attachments`]={type:new m(toOuputList(l.attachmentObject)),resolve:t=>(t.data?.[n]??[]).map(e.fromString)}:r[`${n}Attachment`]={type:l.attachmentObject,resolve:t=>{let i=t.data?.[n];return i?e.fromString(i):null}};break;case"document":{let e,i,a=s.model;if(void 0===a)continue;null===a?(e=null,i=l.documentInterface):(e=getGlobalID(a,t).toString(),this._includedModelIDs.has(e)?i=this._buildDocument(e):(i=l.documentInterface,e=null)),K(o.type)?r[`${n}Documents`]={type:new m(toOuputList(i)),resolve:async(t,i,s)=>{let l=t.data?.[n]??[];return l.length?await s.resolveList(this.getModelIDs(e),l):[]}}:r[`${n}Document`]={type:i,resolve:async(e,t,i)=>{let s=e.data?.[n];return s?await i.loadDocument(s):null}}}}}for(let e of i.interfaces??[]){let i=getGlobalID(e,t).toString();for(let[e,t]of Object.entries(this._relationsTo[i]??{}))for(let i of t)this._includedModelIDs.has(i.model)&&this._buildRelationFields(r,e,i)}for(let[e,i]of Object.entries(this._relationsTo[t]??{}))for(let t of i)this._includedModelIDs.has(t.model)&&this._buildRelationFields(r,e,t);return r}_buildDocumentDataObject(e,t,i){let n=`${e}-data`;if(null!=this._types[n])return this._types[n];let s=t.schema.required??[],l={};for(let[i,n]of Object.entries(t.schema.properties??{})){let t=n.$ref;if(null==t)throw Error(`Missing ref for field ${i} of object ${e}`);let r=this._getReference(t);l[i]={type:s.includes(i)?new m(r):r}}let r={name:`${i}Data`,interfaces:()=>t.interfaces.map(t=>{let i=`${getGlobalID(t,e).toString()}-data`;return this._types[i]}).filter(e=>null!=e),fields:l},o="interface"===t.behavior?new h(r):new _(r);return this._types[n]=o,o}_buildDocumentInput(e,t){if("interface"===t.behavior)return;let i={},n={};for(let[e,s]of Object.entries(t.schema.properties)){let l=s.$ref,r=this._getReferenceInput(l,!1);i[e]={type:t.schema.required.includes(e)?new m(r):r};let o=H(l);null==this._getReferenceSchema(o).const&&(n[e]={type:this._getReferenceInput(l,!0)})}let s=this._aliases[e];this._inputObjects[e]=new p({name:`${s}Input`,fields:i}),this._inputObjects[`${e}-update`]=new p({name:`Partial${s}Input`,fields:n})}_buildReferenceFilterInput(e,t=""){let i=H(e),n=this._getReferenceSchema(i),s=t;if("object"===n.type)return n.additionalProperties?null:this._buildObjectFilterInput(i,n,t);if("array"===n.type){let e=this._aliases[i]??r(t+n.title);return s=e,new p({name:`${e}Filter`,isOneOf:!0,fields:{isNull:{type:a}}})}let l=this._buildScalar(i,n,s),o=W[l.name];if(null!=o)return this._inputObjects[o];let u=w(l)?new p({name:`${l.name}ValueFilter`,isOneOf:!0,fields:{isNull:{type:a},equalTo:{type:l},notEqualTo:{type:l},in:{type:toList(l)},notIn:{type:toList(l)}}}):U(l);return null==this._inputObjects[u.name]&&(this._inputObjects[u.name]=u),this._inputObjects[u.name]}_buildReferenceOrderByInput(e,t=""){let i=H(e),n=this._getReferenceSchema(i);switch(n.type){case"array":return null;case"object":return n.additionalProperties?null:this._buildObjectOrderByInput(i,n,t);default:return Z}}_buildObjectFilterInput(e,t,i="",n=!1){let s=`${e}-filter`,l=this._inputObjects[s];if(null!=l)return l;let o=this._aliases[e]??r(i+(t.title??"")),a=n?{_owner:{type:this._inputObjects.AccountValueFilter}}:{};for(let[e,i]of Object.entries(t.properties)){let t=this._buildReferenceFilterInput(i.$ref,o);null!==t&&(a[e]={type:t})}let u=new p({name:`${o}ObjectFilter`,fields:a}),c=new p({name:`${o}Filter`,isOneOf:!0,fields:()=>({where:{type:u},and:{type:toList(this._inputObjects[s])},or:{type:toList(this._inputObjects[s])},not:{type:this._inputObjects[s]}})});return this._inputObjects[s]=c,c}_buildObjectOrderByInput(e,t,i="",n=!1){let s=`${e}-order`,l=this._inputObjects[s];if(null!=l)return l;let o=this._aliases[e]??r(i+(t.title??"")),a=n?{_docOwner:{type:Z},_createdAt:{type:Z}}:{};for(let[e,i]of Object.entries(t.properties)){let t=this._buildReferenceOrderByInput(i.$ref,o);null!=t&&(a[e]={type:t})}let u=new p({name:`${o}OrderBy`,isOneOf:!0,fields:a});return this._inputObjects[s]=u,u}_buildSetInputObjectType(e,t,i){let n=i?r(i):"",s=`${e}-with-${n}`,l=this._inputObjects[s];if(null!=l)return l;let o=this._record[e],a=this._aliases[e];return this._inputObjects[s]=new p({name:`With${n}${a}Input`,fields:()=>{let e={};for(let i of t){let t=o.schema.properties[i];if(null==t)throw Error(`Field ${i} not found on model ${a}`);let n=this._getReferenceInput(t.$ref,!1);e[i]={type:new m(n)}}return e}}),this._inputObjects[s]}_buildReference(e,t,i=""){if(null!=this._types[e])return this._types[e];switch(t.type){case"array":return this._types[e]=this._buildArray(t,i),this._types[e];case"object":return this._types[e]=t.additionalProperties?k:this._buildObject(e,t,i),this._types[e];default:return this._buildScalar(e,t,i)}}_buildScalar(e,t,i=""){if(null!=this._types[e])return this._types[e];switch(t.type){case"boolean":this._types[e]=a;break;case"integer":this._types[e]=f;break;case"number":this._types[e]=c;break;case"string":this._types[e]=this._buildString(t,i)}return this._types[e]}_buildArray(e,t=""){let i=e.items.$ref;return new y(new m(this._getReference(i,r(t+e.title))))}_buildObject(e,t,i=""){let n=r(i+t.title),s=this._buildObjectFields(e,t,n);return new _({name:n,fields:s})}_buildObjectFields(e,t,i=""){let n=t.required??[],s={};for(let[l,r]of Object.entries(t.properties??{})){let t=r.$ref;if(null==t)throw Error(`Missing ref for field ${l} of object ${e}`);let o=this._getReference(t,i);s[l]={type:n.includes(l)?new m(o):o}}return s}_buildRelationFields(e,t,i){if(i.isList)return;let n=i.model,s=`${r(t)}Of${this._aliases[n]}`;e[`in${s}`]={type:new m(this._types[`${n}-connection`]),args:{...S,filter:{type:this._inputObjects[`${n}-filter`]},orderBy:{type:toList(this._inputObjects[`${n}-order`])}},resolve:(e,i,s)=>{let l={where:{[t]:{equalTo:e.id}}},r=i.filter?{and:[i.filter,l]}:l;return s.resolveConnection(this.getModelIDs(n),{...i,filter:r})}}}_buildRelationSubscriptions(e,t,i,n){if(n.isList)return;let s=r(i);e[`edge${this._aliases[n.model]}AddedAs${s}To${this._aliases[t]}`]={type:new m(this._types[`${n.model}-edge`]),args:{id:{type:new m(d)}},resolve:e=>e,subscribe:(e,t,s)=>s.subscribeToDocumentEdgeAdded(this.getModelIDs(n.model),e=>e[i]===t.id)},e[`edge${this._aliases[n.model]}RemovedAs${s}From${this._aliases[t]}`]={type:new m(d),args:{id:{type:new m(d)}},resolve:e=>e,subscribe:(e,t,s)=>s.subscribeToDocumentEdgeRemoved(this.getModelIDs(n.model),e=>e[i]===t.id)}}_buildString(e,t){return null!=e.const?b:null!=e.enum?this._buildEnumString(e,t):null!=e.format?this._buildFormatString(e):this._buildCustomString(e)}_buildCustomString(e){return null==e.title?b:Q[e.title.toLowerCase()]??b}_buildEnumString(e,t=""){let i=r(t+e.title),n=`${i}-enum`;if(null==this._types[n]){let t={};for(let i of e.enum)t[i]={value:i};this._types[n]=new u({name:i,values:t})}return this._types[n]}_buildFormatString(e){let t=V[e.format];if(null==t)throw Error(`Unsupported string format: ${e.format}`);return t}}export function createSchema(e){return new SchemaBuilder(e).build()}
+import { AttachmentID, DocumentID, DocumentModelID, decodeID, PluginNodeID } from '@kubun/id';
+import { REFERENCE_PREFIX } from '@kubun/protocol';
+import { pascalCase } from 'change-case';
+import { extendSchema, GraphQLBoolean, GraphQLEnumType, GraphQLFloat, GraphQLID, GraphQLInputObjectType, GraphQLInt, GraphQLInterfaceType, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLSchema, GraphQLString, isEnumType, isListType, isNonNullType, isObjectType, isScalarType, Kind, parse as parseGraphQL } from 'graphql';
+import { connectionArgs, connectionDefinitions, mutationWithClientMutationId, nodeDefinitions } from 'graphql-relay';
+import { GraphQLDateTimeISO, GraphQLDID, GraphQLDuration, GraphQLEmailAddress, GraphQLJSON, GraphQLJSONObject } from 'graphql-scalars';
+import { GraphQLAttachmentID, GraphQLDocID } from './identifiers.js';
+import { GraphQLURL } from './scalars.js';
+import { getUniqueDocValue, validateAccessIdentifiers } from './utils.js';
+/**
+ * Create a type-appropriate default value for stubbing extension field resolvers.
+ * Used during client-side pre-execution where extension fields don't need real resolution.
+ */ function createDefaultValue(type) {
+    if (isNonNullType(type)) return createDefaultValue(type.ofType);
+    if (isListType(type)) return [];
+    if (isScalarType(type)) {
+        switch(type.name){
+            case 'String':
+            case 'ID':
+                return '';
+            case 'Int':
+            case 'Float':
+                return 0;
+            case 'Boolean':
+                return false;
+            default:
+                return null;
+        }
+    }
+    if (isEnumType(type)) {
+        const values = type.getValues();
+        return values[0]?.value ?? null;
+    }
+    // Object types: return empty object — sub-fields use their own stub resolvers
+    return {};
+}
+const STRING_FORMATS = {
+    date: GraphQLString,
+    time: GraphQLString,
+    'date-time': GraphQLString,
+    duration: GraphQLDuration,
+    email: GraphQLEmailAddress,
+    uri: GraphQLURL
+};
+const STRING_TITLES = {
+    attachmentid: GraphQLAttachmentID,
+    did: GraphQLDID,
+    docid: GraphQLDocID
+};
+function getReferenceID(path) {
+    return path.slice(REFERENCE_PREFIX.length);
+}
+function isList(type) {
+    return isListType(type) || isNonNullType(type) && isListType(type.ofType);
+}
+function collectAllModelIDs(collected, record, interfaceID) {
+    const implementedBy = record[interfaceID];
+    if (implementedBy == null) {
+        throw new Error(`Interface ${interfaceID} not found in record`);
+    }
+    for (const id of implementedBy){
+        // Check if this id is itself an interface (exists in record with implementers)
+        if (record[id] != null) {
+            // The id is an interface that has implementers, resolve recursively
+            collectAllModelIDs(collected, record, id);
+        } else {
+            // The id is a concrete model
+            collected.add(id);
+        }
+    }
+}
+export function toDocumentModelID(id) {
+    return id instanceof DocumentModelID ? id : DocumentModelID.fromString(id);
+}
+export function getGlobalID(id, globalID) {
+    const docModelID = toDocumentModelID(id);
+    return docModelID.isLocal ? docModelID.toGlobal(toDocumentModelID(globalID)) : docModelID;
+}
+export function toList(type) {
+    return new GraphQLList(new GraphQLNonNull(type));
+}
+export function toOuputList(type) {
+    return new GraphQLList(new GraphQLNonNull(type));
+}
+function createEnumValueFilterInput(type) {
+    return new GraphQLInputObjectType({
+        name: `${type.name}ValueFilter`,
+        isOneOf: true,
+        fields: {
+            isNull: {
+                type: GraphQLBoolean
+            },
+            equalTo: {
+                type
+            },
+            notEqualTo: {
+                type
+            },
+            in: {
+                type: toList(type)
+            },
+            notIn: {
+                type: toList(type)
+            }
+        }
+    });
+}
+function createScalarValueFilterInput(type) {
+    return new GraphQLInputObjectType({
+        name: `${type.name}ValueFilter`,
+        isOneOf: true,
+        fields: {
+            isNull: {
+                type: GraphQLBoolean
+            },
+            equalTo: {
+                type
+            },
+            notEqualTo: {
+                type
+            },
+            in: {
+                type: toList(type)
+            },
+            notIn: {
+                type: toList(type)
+            },
+            lessThan: {
+                type
+            },
+            lessThanOrEqualTo: {
+                type
+            },
+            greaterThan: {
+                type
+            },
+            greaterThanOrEqualTo: {
+                type
+            }
+        }
+    });
+}
+const VALUE_FILTER_INPUTS = {
+    AccountValueFilter: new GraphQLInputObjectType({
+        name: 'AccountValueFilter',
+        isOneOf: true,
+        fields: {
+            equalTo: {
+                type: GraphQLDID
+            },
+            notEqualTo: {
+                type: GraphQLDID
+            },
+            in: {
+                type: toList(GraphQLDID)
+            },
+            notIn: {
+                type: toList(GraphQLDID)
+            }
+        }
+    }),
+    BooleanValueFilter: new GraphQLInputObjectType({
+        name: 'BooleanValueFilter',
+        isOneOf: true,
+        fields: {
+            isNull: {
+                type: GraphQLBoolean
+            },
+            equalTo: {
+                type: GraphQLBoolean
+            }
+        }
+    }),
+    FloatValueFilter: createScalarValueFilterInput(GraphQLFloat),
+    IntValueFilter: createScalarValueFilterInput(GraphQLInt),
+    StringValueFilter: createScalarValueFilterInput(GraphQLString)
+};
+const VALUE_FILTER_INPUT_TYPES = {
+    GraphQLBoolean: 'BooleanValueFilter',
+    GraphQLDID: 'AccountValueFilter',
+    GraphQLFloat: 'FloatValueFilter',
+    GraphQLInt: 'IntValueFilter',
+    GraphQLString: 'StringValueFilter'
+};
+const PatchSetOperation = new GraphQLInputObjectType({
+    name: 'PatchSetOperation',
+    fields: {
+        path: {
+            type: new GraphQLNonNull(GraphQLString)
+        },
+        value: {
+            type: GraphQLJSON
+        }
+    }
+});
+const PatchRemoveOperation = new GraphQLInputObjectType({
+    name: 'PatchRemoveOperation',
+    fields: {
+        path: {
+            type: new GraphQLNonNull(GraphQLString)
+        }
+    }
+});
+const PatchDestinationOperation = new GraphQLInputObjectType({
+    name: 'PatchDestinationOperation',
+    fields: {
+        from: {
+            type: new GraphQLNonNull(GraphQLString)
+        },
+        path: {
+            type: new GraphQLNonNull(GraphQLString)
+        }
+    }
+});
+export const PatchOperation = new GraphQLInputObjectType({
+    name: 'PatchOperation',
+    isOneOf: true,
+    fields: {
+        add: {
+            type: PatchSetOperation
+        },
+        set: {
+            type: PatchSetOperation
+        },
+        remove: {
+            type: PatchRemoveOperation
+        },
+        replace: {
+            type: PatchSetOperation
+        },
+        copy: {
+            type: PatchDestinationOperation
+        },
+        move: {
+            type: PatchDestinationOperation
+        }
+    }
+});
+const OrderByDirection = new GraphQLEnumType({
+    name: 'OrderByDirection',
+    values: {
+        ASC: {
+            value: 'asc'
+        },
+        DESC: {
+            value: 'desc'
+        }
+    }
+});
+const AccessRule = new GraphQLObjectType({
+    name: 'AccessRule',
+    fields: {
+        level: {
+            type: new GraphQLNonNull(GraphQLString)
+        },
+        allowedDIDs: {
+            type: new GraphQLList(new GraphQLNonNull(GraphQLString))
+        },
+        allowedCircles: {
+            type: new GraphQLList(new GraphQLNonNull(GraphQLString))
+        },
+        allowedGroups: {
+            type: new GraphQLList(new GraphQLNonNull(GraphQLString))
+        }
+    }
+});
+const AccessPermissions = new GraphQLObjectType({
+    name: 'AccessPermissions',
+    fields: {
+        read: {
+            type: AccessRule
+        },
+        write: {
+            type: AccessRule
+        }
+    }
+});
+const ModelAccessDefaults = new GraphQLObjectType({
+    name: 'ModelAccessDefaults',
+    fields: ()=>({
+            ownerDID: {
+                type: new GraphQLNonNull(GraphQLString)
+            },
+            modelID: {
+                type: new GraphQLNonNull(GraphQLID)
+            },
+            permissions: {
+                type: new GraphQLNonNull(AccessPermissions)
+            }
+        })
+});
+export class SchemaBuilder {
+    // Mapping of model or references IDs to their GraphQL object names
+    _aliases;
+    _aliasToModelID;
+    // Per-model map of aggregatable field key -> whether it is numeric. Drives the
+    // SQL numeric cast so JSON-extracted values compare arithmetically ('9' < '10')
+    // rather than lexically. Populated by `_buildAggregate`.
+    _aggregateNumericByModel = {};
+    // Per-model map of groupable field key -> whether it is numeric. Broader than
+    // aggregate eligibility (includes boolean and enum fields). Drives the SQL numeric
+    // cast on group keys so JSON-extracted values compare arithmetically rather than
+    // lexically. Populated by `_buildGroupedAggregate`.
+    _groupKeyNumericByModel = {};
+    _definitions;
+    _implemented = {};
+    _includedModelIDs;
+    _includeInterfaceDependencies;
+    _includeMutations;
+    _includeRelationDependencies;
+    _includeSubscriptions;
+    _inputObjects = {
+        ...VALUE_FILTER_INPUTS,
+        PatchOperation
+    };
+    _mutations = {};
+    _nodeModelIDs;
+    _onlyModels;
+    _record;
+    _references = {};
+    _relationsTo = {};
+    _extensionSDL;
+    _extensionResolvers;
+    _stubExtensionResolvers;
+    _pluginNodeResolvers = {};
+    _subscriptions = {};
+    _types = {
+        OrderByDirection
+    };
+    constructor(params){
+        this._record = params.record;
+        this._onlyModels = params.onlyModels ?? null;
+        this._includeInterfaceDependencies = params.includeInterfaceDependencies ?? true;
+        this._includeRelationDependencies = params.includeRelationDependencies ?? true;
+        this._includeMutations = params.includeMutations ?? true;
+        this._includeSubscriptions = params.includeSubscriptions ?? true;
+        this._extensionSDL = params.extensionSDL;
+        this._extensionResolvers = params.extensionResolvers;
+        this._stubExtensionResolvers = params.stubExtensionResolvers ?? false;
+        // params.aliases is { aliasName: modelID }, which is what we need for _aliasToModelID
+        this._aliasToModelID = params.aliases ?? {};
+        // Build reverse lookup map (modelID -> alias) for internal use
+        this._aliases = {};
+        for (const [alias, modelID] of Object.entries(this._aliasToModelID)){
+            this._aliases[modelID] = alias;
+        }
+        // Populate fallback aliases from model names for any models without explicit aliases
+        for (const [id, model] of Object.entries(params.record)){
+            if (this._aliases[id] == null) {
+                const name = pascalCase(model.name);
+                this._aliases[id] = name;
+                this._aliasToModelID[name] ??= id;
+            }
+        }
+        // Compute which models to include
+        this._includedModelIDs = this._resolveModelIDsToInclude();
+        const referencedInterfaces = {};
+        for (const [modelIDstring, model] of Object.entries(params.record)){
+            const modelID = DocumentModelID.fromString(modelIDstring);
+            Object.assign(this._references, model.schema.$defs ?? {});
+            // Extract interfaces
+            for (const iid of model.interfaces){
+                const interfaceID = getGlobalID(iid, modelID).toString();
+                referencedInterfaces[interfaceID] ??= new Set();
+                referencedInterfaces[interfaceID].add(modelIDstring);
+            }
+            // Extract inverse relations
+            for (const [fieldName, meta] of Object.entries(model.fieldsMeta)){
+                if (meta.type === 'document' && meta.model != null) {
+                    const relationRefID = getReferenceID(model.schema.properties[fieldName]?.$ref);
+                    const isList = this._getReferenceSchema(relationRefID).type === 'array';
+                    const relationID = getGlobalID(meta.model, modelID).toString();
+                    this._relationsTo[relationID] ??= {};
+                    this._relationsTo[relationID][fieldName] ??= [];
+                    this._relationsTo[relationID][fieldName].push({
+                        model: modelIDstring,
+                        isList
+                    });
+                }
+            }
+        }
+        // Map interface IDs to all the models implementing them
+        const nodeModelIDs = new Set();
+        for (const id of Object.keys(referencedInterfaces)){
+            const implementedBy = new Set();
+            collectAllModelIDs(implementedBy, referencedInterfaces, id);
+            if (implementedBy.size !== 0) {
+                this._implemented[id] = Array.from(implementedBy);
+            }
+            for (const modelID of implementedBy){
+                nodeModelIDs.add(modelID);
+            }
+        }
+        this._nodeModelIDs = Array.from(nodeModelIDs);
+    }
+    _resolveModelIdentifier(identifier) {
+        // Check if it's a model ID (exists in record)
+        if (this._record[identifier] != null) {
+            return identifier;
+        }
+        // Check if it's an alias
+        const modelID = this._aliasToModelID[identifier];
+        if (modelID != null && this._record[modelID] != null) {
+            return modelID;
+        }
+        throw new Error(`Model identifier "${identifier}" not found. Must be a valid model ID or alias.`);
+    }
+    _resolveModelIDsToInclude() {
+        // If no restriction, include all models
+        if (this._onlyModels == null || this._onlyModels.length === 0) {
+            return new Set(Object.keys(this._record));
+        }
+        // Resolve identifiers to model IDs
+        const included = new Set();
+        for (const identifier of this._onlyModels){
+            const modelID = this._resolveModelIdentifier(identifier);
+            included.add(modelID);
+        }
+        // If both dependencies are disabled, return early
+        if (!this._includeInterfaceDependencies && !this._includeRelationDependencies) {
+            return included;
+        }
+        // Recursively collect dependencies
+        const toProcess = Array.from(included);
+        const processed = new Set();
+        while(toProcess.length > 0){
+            const modelID = toProcess.pop();
+            if (modelID == null || processed.has(modelID)) continue;
+            processed.add(modelID);
+            const model = this._record[modelID];
+            if (model == null) continue;
+            // Add interface dependencies if enabled
+            if (this._includeInterfaceDependencies) {
+                for (const iid of model.interfaces){
+                    const interfaceID = getGlobalID(iid, modelID).toString();
+                    if (!included.has(interfaceID)) {
+                        included.add(interfaceID);
+                        toProcess.push(interfaceID);
+                    }
+                }
+            }
+            // Add relation dependencies if enabled
+            if (this._includeRelationDependencies) {
+                for (const meta of Object.values(model.fieldsMeta)){
+                    if (meta.type === 'document' && meta.model != null && meta.model !== null) {
+                        const relationID = getGlobalID(meta.model, modelID).toString();
+                        if (!included.has(relationID)) {
+                            included.add(relationID);
+                            toProcess.push(relationID);
+                        }
+                    }
+                }
+            }
+        }
+        return included;
+    }
+    getModelIDs(id) {
+        return id === null ? this._nodeModelIDs : this._implemented[id] ?? [
+            id
+        ];
+    }
+    build() {
+        const definitions = this._buildSharedDefinitions();
+        this._definitions = definitions;
+        const queryFields = {
+            nodes: definitions.nodesField,
+            ...definitions.queryFields
+        };
+        for (const id of this._includedModelIDs){
+            this._buildDocument(id);
+            const name = this._aliases[id];
+            const filterArg = {
+                type: this._inputObjects[`${id}-filter`]
+            };
+            queryFields[`all${name}`] = {
+                type: this._types[`${id}-connection`],
+                args: {
+                    ...connectionArgs,
+                    filter: filterArg,
+                    orderBy: {
+                        type: toList(this._inputObjects[`${id}-order`])
+                    },
+                    search: {
+                        type: GraphQLString
+                    }
+                },
+                resolve: async (_, args, ctx)=>{
+                    return await ctx.resolveConnection(this.getModelIDs(id), args);
+                }
+            };
+        }
+        // Add top-level search query across all models
+        // Get the PageInfo type from an existing connection (shared by graphql-relay)
+        const firstModelID = [
+            ...this._includedModelIDs
+        ][0];
+        if (firstModelID != null) {
+            const someConnectionType = this._types[`${firstModelID}-connection`];
+            const pageInfoType = someConnectionType.getFields().pageInfo.type;
+            const searchResultEdge = new GraphQLObjectType({
+                name: 'SearchResultEdge',
+                fields: ()=>({
+                        cursor: {
+                            type: new GraphQLNonNull(GraphQLString)
+                        },
+                        node: {
+                            type: new GraphQLNonNull(definitions.nodeInterface)
+                        },
+                        rank: {
+                            type: new GraphQLNonNull(GraphQLFloat)
+                        }
+                    })
+            });
+            const searchResultConnection = new GraphQLObjectType({
+                name: 'SearchResultConnection',
+                fields: ()=>({
+                        edges: {
+                            type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(searchResultEdge)))
+                        },
+                        pageInfo: {
+                            type: pageInfoType
+                        }
+                    })
+            });
+            queryFields.search = {
+                type: new GraphQLNonNull(searchResultConnection),
+                args: {
+                    query: {
+                        type: new GraphQLNonNull(GraphQLString)
+                    },
+                    models: {
+                        type: new GraphQLList(new GraphQLNonNull(GraphQLString))
+                    },
+                    first: {
+                        type: GraphQLInt
+                    },
+                    after: {
+                        type: GraphQLString
+                    }
+                },
+                resolve: async (_root, args, ctx)=>{
+                    const { query, models, first } = args;
+                    if (query.trim() === '') {
+                        throw new Error('Search query must not be empty');
+                    }
+                    // Map model names to IDs
+                    const modelIDs = models ? models.map((name)=>this._aliasToModelID[name] ?? name) : [
+                        ...this._includedModelIDs
+                    ];
+                    const results = await ctx.searchDocuments(query, modelIDs, first ?? 20);
+                    // Load documents
+                    const docIDs = results.map((r)=>r.documentID);
+                    const allModelIDs = [
+                        ...new Set(results.map((r)=>r.modelID))
+                    ];
+                    const documents = docIDs.length > 0 ? await ctx.resolveList(allModelIDs, docIDs) : [];
+                    const docMap = new Map(documents.map((d)=>[
+                            d.id,
+                            d
+                        ]));
+                    const edges = [];
+                    for (const r of results){
+                        const node = docMap.get(r.documentID);
+                        if (node != null) {
+                            edges.push({
+                                cursor: String(edges.length),
+                                node,
+                                rank: Math.abs(r.rank)
+                            });
+                        }
+                    }
+                    return {
+                        edges,
+                        pageInfo: {
+                            hasNextPage: false,
+                            hasPreviousPage: false,
+                            startCursor: edges.length > 0 ? edges[0].cursor : null,
+                            endCursor: edges.length > 0 ? edges[edges.length - 1].cursor : null
+                        }
+                    };
+                }
+            };
+        }
+        // Introspection: the viewer's own model-access-default rows. The stored
+        // rows are one-per-(model, permissionType); group them by modelID so each
+        // result groups read+write into `permissions`, matching `ModelAccessDefaults`.
+        queryFields.modelAccessDefaults = {
+            type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(ModelAccessDefaults))),
+            resolve: async (_root, _args, ctx)=>{
+                const viewerDID = ctx.getViewer();
+                // The rows are the viewer's OWN defaults and `ownerDID` names the viewer.
+                // With no viewer there is no owner to name, and no own rows to return.
+                if (viewerDID == null) {
+                    return [];
+                }
+                const rows = await ctx.listModelAccessDefaults();
+                const byModelID = new Map();
+                for (const row of rows){
+                    let entry = byModelID.get(row.modelID);
+                    if (entry == null) {
+                        entry = {
+                            ownerDID: viewerDID,
+                            modelID: row.modelID,
+                            permissions: {}
+                        };
+                        byModelID.set(row.modelID, entry);
+                    }
+                    entry.permissions[row.permissionType] = {
+                        level: row.level,
+                        allowedDIDs: row.allowedDIDs,
+                        allowedCircles: row.allowedCircles,
+                        allowedGroups: row.allowedGroups
+                    };
+                }
+                return [
+                    ...byModelID.values()
+                ];
+            }
+        };
+        // Add access control mutations if mutations are enabled
+        if (this._includeMutations) {
+            this._mutations.setModelAccessDefaults = {
+                type: ModelAccessDefaults,
+                args: {
+                    modelID: {
+                        type: new GraphQLNonNull(GraphQLID)
+                    },
+                    permissionType: {
+                        type: new GraphQLNonNull(GraphQLString)
+                    },
+                    accessLevel: {
+                        type: new GraphQLNonNull(GraphQLString)
+                    },
+                    allowedDIDs: {
+                        type: toList(GraphQLString)
+                    },
+                    allowedCircles: {
+                        type: toList(GraphQLString)
+                    },
+                    allowedGroups: {
+                        type: toList(GraphQLString)
+                    }
+                },
+                resolve: async (_, args, ctx)=>{
+                    const allowedDIDs = args.allowedDIDs ?? null;
+                    const allowedCircles = args.allowedCircles ?? null;
+                    const allowedGroups = args.allowedGroups ?? null;
+                    validateAccessIdentifiers({
+                        allowedDIDs,
+                        allowedCircles,
+                        allowedGroups
+                    });
+                    return await ctx.executeSetModelAccessDefaults({
+                        modelID: args.modelID,
+                        permissionType: args.permissionType,
+                        accessLevel: args.accessLevel,
+                        allowedDIDs,
+                        allowedCircles,
+                        allowedGroups
+                    });
+                }
+            };
+            this._mutations.removeModelAccessDefaults = {
+                type: GraphQLBoolean,
+                args: {
+                    modelID: {
+                        type: new GraphQLNonNull(GraphQLID)
+                    },
+                    permissionTypes: {
+                        type: new GraphQLNonNull(toList(GraphQLString))
+                    }
+                },
+                resolve: async (_, args, ctx)=>{
+                    await ctx.executeRemoveModelAccessDefaults(args.modelID, args.permissionTypes);
+                    return true;
+                }
+            };
+            this._mutations.setDocumentAccessOverride = {
+                type: definitions.documentInterface,
+                args: {
+                    documentID: {
+                        type: new GraphQLNonNull(GraphQLID)
+                    },
+                    permissionType: {
+                        type: new GraphQLNonNull(GraphQLString)
+                    },
+                    accessLevel: {
+                        type: new GraphQLNonNull(GraphQLString)
+                    },
+                    allowedDIDs: {
+                        type: toList(GraphQLString)
+                    },
+                    allowedCircles: {
+                        type: toList(GraphQLString)
+                    },
+                    allowedGroups: {
+                        type: toList(GraphQLString)
+                    }
+                },
+                resolve: async (_, args, ctx)=>{
+                    const allowedDIDs = args.allowedDIDs ?? null;
+                    const allowedCircles = args.allowedCircles ?? null;
+                    const allowedGroups = args.allowedGroups ?? null;
+                    validateAccessIdentifiers({
+                        allowedDIDs,
+                        allowedCircles,
+                        allowedGroups
+                    });
+                    return await ctx.executeSetDocumentAccessOverride({
+                        documentID: args.documentID,
+                        permissionType: args.permissionType,
+                        accessLevel: args.accessLevel,
+                        allowedDIDs,
+                        allowedCircles,
+                        allowedGroups
+                    });
+                }
+            };
+            this._mutations.removeDocumentAccessOverride = {
+                type: GraphQLBoolean,
+                args: {
+                    documentID: {
+                        type: new GraphQLNonNull(GraphQLID)
+                    },
+                    permissionTypes: {
+                        type: new GraphQLNonNull(toList(GraphQLString))
+                    }
+                },
+                resolve: async (_, args, ctx)=>{
+                    await ctx.executeRemoveDocumentAccessOverride(args.documentID, args.permissionTypes);
+                    return true;
+                }
+            };
+            // Transaction lifecycle mutations
+            const BeginTransactionPayload = new GraphQLObjectType({
+                name: 'BeginTransactionPayload',
+                fields: {
+                    transactionID: {
+                        type: new GraphQLNonNull(GraphQLID)
+                    }
+                }
+            });
+            const CommitTransactionPayload = new GraphQLObjectType({
+                name: 'CommitTransactionPayload',
+                fields: {
+                    success: {
+                        type: new GraphQLNonNull(GraphQLBoolean)
+                    }
+                }
+            });
+            const RollbackTransactionPayload = new GraphQLObjectType({
+                name: 'RollbackTransactionPayload',
+                fields: {
+                    success: {
+                        type: new GraphQLNonNull(GraphQLBoolean)
+                    }
+                }
+            });
+            this._mutations.beginTransaction = {
+                type: new GraphQLNonNull(BeginTransactionPayload),
+                args: {},
+                resolve: (_, _args, ctx)=>{
+                    return ctx.beginTransaction();
+                }
+            };
+            this._mutations.commitTransaction = {
+                type: new GraphQLNonNull(CommitTransactionPayload),
+                args: {
+                    transactionID: {
+                        type: new GraphQLNonNull(GraphQLID)
+                    }
+                },
+                resolve: async (_, args, ctx)=>{
+                    return await ctx.commitTransaction(args.transactionID);
+                }
+            };
+            this._mutations.rollbackTransaction = {
+                type: new GraphQLNonNull(RollbackTransactionPayload),
+                args: {
+                    transactionID: {
+                        type: new GraphQLNonNull(GraphQLID)
+                    }
+                },
+                resolve: (_, args, ctx)=>{
+                    return ctx.rollbackTransaction(args.transactionID);
+                }
+            };
+        }
+        const config = {
+            query: new GraphQLObjectType({
+                name: 'Query',
+                fields: queryFields
+            }),
+            // Ensure custom scalars stay reachable from the schema typeMap so plugin
+            // SDL extensions can reference them by name (URL, DID, DateTimeISO)
+            // regardless of whether any model field happens to use them.
+            types: [
+                GraphQLURL,
+                GraphQLDID,
+                GraphQLDateTimeISO
+            ]
+        };
+        if (this._includeMutations) {
+            config.mutation = new GraphQLObjectType({
+                name: 'Mutation',
+                fields: this._mutations
+            });
+        }
+        if (this._includeSubscriptions) {
+            config.subscription = new GraphQLObjectType({
+                name: 'Subscription',
+                fields: ()=>{
+                    const fields = {
+                        ...this._subscriptions
+                    };
+                    if (this._includeSubscriptions) {
+                        fields.documentChanged = {
+                            type: new GraphQLNonNull(definitions.documentInterface),
+                            args: {
+                                id: {
+                                    type: new GraphQLNonNull(GraphQLID)
+                                }
+                            },
+                            resolve: (doc)=>doc,
+                            subscribe: (_, args, ctx)=>{
+                                return ctx.subscribeToDocumentChanged(args.id);
+                            }
+                        };
+                        fields.documentRemoved = {
+                            type: new GraphQLNonNull(GraphQLID),
+                            resolve: (id)=>id,
+                            subscribe: (_src, _args, ctx)=>{
+                                return ctx.subscribeToDocumentRemoved();
+                            }
+                        };
+                        for (const [id, model] of Object.entries(this._record)){
+                            if (!this._includedModelIDs.has(id)) continue;
+                            const name = this._aliases[id];
+                            fields[`new${name}Created`] = {
+                                type: new GraphQLNonNull(this._types[id]),
+                                args: {
+                                    owner: {
+                                        type: GraphQLID
+                                    }
+                                },
+                                resolve: (doc)=>doc,
+                                subscribe: (_src, args, ctx)=>{
+                                    return ctx.subscribeToDocumentCreated(this.getModelIDs(id), args.owner ?? undefined);
+                                }
+                            };
+                            for (const iid of model.interfaces ?? []){
+                                const interfaceID = getGlobalID(iid, id).toString();
+                                for (const [fieldName, relations] of Object.entries(this._relationsTo[interfaceID] ?? {})){
+                                    for (const relation of relations){
+                                        this._buildRelationSubscriptions(fields, interfaceID, fieldName, relation);
+                                    }
+                                }
+                            }
+                            for (const [fieldName, relations] of Object.entries(this._relationsTo[id] ?? {})){
+                                for (const relation of relations){
+                                    if (!this._includedModelIDs.has(relation.model)) continue;
+                                    this._buildRelationSubscriptions(fields, id, fieldName, relation);
+                                }
+                            }
+                        }
+                    }
+                    return fields;
+                }
+            });
+        }
+        let schema = new GraphQLSchema(config);
+        // Apply SDL extensions
+        if (this._extensionSDL != null) {
+            const typesBefore = new Set(Object.keys(schema.getTypeMap()));
+            schema = extendSchema(schema, parseGraphQL(this._extensionSDL));
+            // Stub extension resolvers for client-side pre-execution
+            if (this._stubExtensionResolvers) {
+                this.#stubExtensionFields(schema, typesBefore);
+            }
+        }
+        // Attach resolvers to extended fields
+        if (this._extensionResolvers != null) {
+            this.#attachExtensionResolvers(schema, this._extensionResolvers);
+        }
+        return schema;
+    }
+    #attachExtensionResolvers(schema, resolvers) {
+        const queryType = schema.getQueryType();
+        if (queryType != null && resolvers.queryFields != null) {
+            const fields = queryType.getFields();
+            for (const [name, resolver] of Object.entries(resolvers.queryFields)){
+                if (fields[name] == null) {
+                    throw new Error(`Extension resolver for query field "${name}" has no matching field in SDL`);
+                }
+                fields[name].resolve = resolver;
+            }
+        }
+        const mutationType = schema.getMutationType();
+        if (mutationType != null && resolvers.mutationFields != null) {
+            const fields = mutationType.getFields();
+            for (const [name, resolver] of Object.entries(resolvers.mutationFields)){
+                if (fields[name] == null) {
+                    throw new Error(`Extension resolver for mutation field "${name}" has no matching field in SDL`);
+                }
+                fields[name].resolve = resolver;
+            }
+        }
+        const subscriptionType = schema.getSubscriptionType();
+        if (subscriptionType != null && resolvers.subscriptionFields != null) {
+            const fields = subscriptionType.getFields();
+            for (const [name, entry] of Object.entries(resolvers.subscriptionFields)){
+                if (fields[name] == null) {
+                    throw new Error(`Extension resolver for subscription field "${name}" has no matching field in SDL`);
+                }
+                fields[name].resolve = entry.resolve;
+                fields[name].subscribe = entry.subscribe;
+            }
+        }
+        if (resolvers.typeFields != null) {
+            for (const [typeName, fieldResolvers] of Object.entries(resolvers.typeFields)){
+                const type = schema.getType(typeName);
+                if (type == null) {
+                    throw new Error(`Extension resolver references type "${typeName}" which does not exist in the schema`);
+                }
+                if (!isObjectType(type)) {
+                    throw new Error(`Extension resolver references type "${typeName}" which is not an object type`);
+                }
+                const fields = type.getFields();
+                for (const [fieldName, resolver] of Object.entries(fieldResolvers)){
+                    if (fields[fieldName] == null) {
+                        throw new Error(`Extension resolver for field "${fieldName}" on type "${typeName}" has no matching field in SDL`);
+                    }
+                    fields[fieldName].resolve = resolver;
+                }
+            }
+        }
+        if (resolvers.nodeResolvers != null) {
+            for (const [typeName, resolver] of Object.entries(resolvers.nodeResolvers)){
+                this._pluginNodeResolvers[typeName] = resolver;
+            }
+        }
+    }
+    #stubExtensionFields(schema, typesBefore) {
+        // Stub root Query/Mutation fields added by extension SDL
+        for (const rootType of [
+            schema.getQueryType(),
+            schema.getMutationType()
+        ]){
+            if (rootType == null) continue;
+            const fields = rootType.getFields();
+            for (const field of Object.values(fields)){
+                if (field.resolve == null) {
+                    field.resolve = ()=>createDefaultValue(field.type);
+                }
+            }
+        }
+        // Stub fields on types added by extension SDL
+        for (const [typeName, type] of Object.entries(schema.getTypeMap())){
+            if (typesBefore.has(typeName)) continue;
+            if (!isObjectType(type)) continue;
+            const fields = type.getFields();
+            for (const field of Object.values(fields)){
+                if (field.resolve == null) {
+                    const fieldType = field.type;
+                    field.resolve = (source)=>source[field.name] ?? createDefaultValue(fieldType);
+                }
+            }
+        }
+    }
+    _getDefinitions() {
+        if (this._definitions == null) {
+            throw new Error('Definitions must be initialized');
+        }
+        return this._definitions;
+    }
+    _getReference(path, parentName) {
+        const id = getReferenceID(path);
+        const type = this._types[id];
+        if (type != null) {
+            return type;
+        }
+        const schema = this._getReferenceSchema(id);
+        return this._buildReference(id, schema, parentName);
+    }
+    _getReferenceSchema(id) {
+        const schema = this._references[id];
+        if (schema == null) {
+            throw new Error(`Could not find reference: ${id}`);
+        }
+        return schema;
+    }
+    _getReferenceInput(path, isPartial, parentName = '') {
+        const id = getReferenceID(path);
+        const schema = this._getReferenceSchema(id);
+        if (schema.type === 'array') {
+            const itemType = this._getReferenceInput(schema.items.$ref, false, schema.title);
+            return new GraphQLList(new GraphQLNonNull(itemType));
+        }
+        if (schema.type === 'object') {
+            if (schema.additionalProperties) {
+                return GraphQLJSONObject;
+            }
+            const inputID = isPartial ? `${id}-partial` : id;
+            const existing = this._inputObjects[inputID];
+            if (existing != null) {
+                return existing;
+            }
+            const fields = {};
+            for (const [key, value] of Object.entries(schema.properties)){
+                const type = this._getReferenceInput(value.$ref, isPartial, schema.title);
+                fields[key] = {
+                    type: isPartial || !schema.required.includes(key) ? type : new GraphQLNonNull(type)
+                };
+            }
+            const name = this._aliases[id] ?? pascalCase(parentName + schema.title);
+            const input = new GraphQLInputObjectType({
+                name: isPartial ? `Partial${name}Input` : `${name}Input`,
+                fields
+            });
+            this._inputObjects[inputID] = input;
+            return input;
+        }
+        return this._buildScalar(id, schema, parentName);
+    }
+    _buildSharedDefinitions() {
+        const nodeDefs = nodeDefinitions(async (id, ctx)=>{
+            if (id.startsWith('did:')) {
+                return id;
+            }
+            const decoded = decodeID(id);
+            if (decoded instanceof AttachmentID) {
+                return decoded;
+            }
+            if (decoded instanceof DocumentID) {
+                return await ctx.loadDocument(id);
+            }
+            if (decoded instanceof PluginNodeID) {
+                const resolver = this._pluginNodeResolvers[decoded.typeName];
+                if (resolver == null) {
+                    throw new Error(`No node resolver registered for plugin type "${decoded.typeName}"`);
+                }
+                const result = await resolver.resolve(decoded.localID, ctx);
+                if (result == null) {
+                    throw new Error(`Node resolver for "${decoded.typeName}" returned null for localID "${decoded.localID}"`);
+                }
+                return {
+                    ...result,
+                    __typename: decoded.typeName
+                };
+            }
+            throw new Error(`Unsupported node ID: ${id}`);
+        }, (node)=>{
+            if (typeof node === 'string') return 'AccountNode';
+            if (node instanceof AttachmentID) return 'AttachmentNode';
+            if (node != null && typeof node === 'object' && 'model' in node) {
+                return this._aliases[node.model];
+            }
+            if (node != null && typeof node === 'object' && '__typename' in node) {
+                return node.__typename;
+            }
+            throw new Error('Unknown node type');
+        });
+        const accountObject = new GraphQLObjectType({
+            name: 'AccountNode',
+            interfaces: [
+                nodeDefs.nodeInterface
+            ],
+            fields: ()=>{
+                const config = {
+                    id: {
+                        type: new GraphQLNonNull(GraphQLID),
+                        description: 'Globally unique identifier of the account (DID string)',
+                        resolve: (did)=>did
+                    },
+                    isViewer: {
+                        type: new GraphQLNonNull(GraphQLBoolean),
+                        description: 'Whether the authenticated request issuer is this account or not',
+                        resolve: (did, _, ctx)=>ctx.getViewer() === did
+                    }
+                };
+                for (const [id, model] of Object.entries(this._record)){
+                    if (!this._includedModelIDs.has(id)) continue;
+                    switch(model.behavior){
+                        case 'interface':
+                            continue;
+                        case 'default':
+                            {
+                                const name = this._aliases[id];
+                                config[`own${name}Connection`] = {
+                                    type: this._types[`${id}-connection`],
+                                    args: {
+                                        ...connectionArgs,
+                                        filter: {
+                                            type: this._inputObjects[`${id}-filter`]
+                                        },
+                                        orderBy: {
+                                            type: toList(this._inputObjects[`${id}-order`])
+                                        }
+                                    },
+                                    resolve: async (owner, args, ctx)=>{
+                                        return await ctx.resolveConnection(this.getModelIDs(id), {
+                                            ...args,
+                                            owner
+                                        });
+                                    }
+                                };
+                                break;
+                            }
+                        case 'unique':
+                            {
+                                const name = this._aliases[id];
+                                config[`own${name}`] = {
+                                    type: this._types[id],
+                                    args: model.uniqueFields.length ? {
+                                        with: {
+                                            type: new GraphQLNonNull(this._buildSetInputObjectType(id, model.uniqueFields))
+                                        }
+                                    } : {},
+                                    resolve: async (owner, args, ctx)=>{
+                                        const unique = getUniqueDocValue(model.uniqueFields, args.with);
+                                        const docID = DocumentID.create(id, owner, unique);
+                                        return await ctx.loadDocument(docID.toString());
+                                    }
+                                };
+                            }
+                    }
+                }
+                return config;
+            }
+        });
+        const attachmentObject = new GraphQLObjectType({
+            name: 'AttachmentNode',
+            interfaces: [
+                nodeDefs.nodeInterface
+            ],
+            fields: {
+                id: {
+                    type: new GraphQLNonNull(GraphQLID),
+                    resolve: (aid)=>aid.toString()
+                },
+                contentLength: {
+                    type: new GraphQLNonNull(GraphQLInt)
+                },
+                mimeType: {
+                    type: new GraphQLNonNull(GraphQLString)
+                }
+            }
+        });
+        const documentNodeFields = {
+            // Node interface
+            id: {
+                type: new GraphQLNonNull(GraphQLID)
+            },
+            // Metadata
+            model: {
+                type: new GraphQLNonNull(GraphQLString)
+            },
+            owner: {
+                type: new GraphQLNonNull(accountObject)
+            },
+            createdAt: {
+                type: new GraphQLNonNull(GraphQLDateTimeISO)
+            },
+            updatedAt: {
+                type: GraphQLDateTimeISO
+            },
+            // Access control
+            accessPermissions: {
+                type: AccessPermissions,
+                resolve: (doc)=>doc.data?.accessPermissions ?? null
+            }
+        };
+        const documentInterface = new GraphQLInterfaceType({
+            name: 'DocumentNode',
+            interfaces: [
+                nodeDefs.nodeInterface
+            ],
+            fields: documentNodeFields,
+            resolveType: (doc)=>this._aliases[doc.model]
+        });
+        const queryFields = {
+            node: nodeDefs.nodeField,
+            viewer: {
+                type: accountObject,
+                description: 'Account issuing the request, if authenticated',
+                resolve: (_self, _args, ctx)=>ctx.getViewer()
+            }
+        };
+        return {
+            ...nodeDefs,
+            accountObject,
+            attachmentObject,
+            documentInterface,
+            documentNodeFields,
+            queryFields
+        };
+    }
+    _buildDocument(id) {
+        if (this._types[id] != null) {
+            return this._types[id];
+        }
+        const model = this._record[id];
+        if (model == null) {
+            throw new Error(`Could not find model id: ${id}`);
+        }
+        const definitions = this._getDefinitions();
+        this._aliases[id] ??= pascalCase(model.name);
+        const name = this._aliases[id];
+        const config = {
+            name,
+            interfaces: ()=>{
+                return [
+                    definitions.documentInterface,
+                    definitions.nodeInterface
+                ].concat(model.interfaces.map((interfaceID)=>{
+                    return this._types[getGlobalID(interfaceID, id).toString()];
+                }).filter((type)=>type != null));
+            },
+            fields: ()=>this._buildDocumentFields(id, model, name)
+        };
+        const isInterface = model.behavior === 'interface';
+        const nodeType = isInterface ? new GraphQLInterfaceType({
+            ...config,
+            resolveType: (doc)=>this._aliases[doc.model]
+        }) : new GraphQLObjectType(config);
+        const aggregateType = this._buildAggregate(id, model, name);
+        const groupedAggregateType = this._buildGroupedAggregate(id, model, name);
+        const { connectionType, edgeType } = connectionDefinitions({
+            nodeType,
+            connectionFields: ()=>{
+                const fields = {
+                    aggregates: {
+                        type: aggregateType,
+                        // The connection carries the query scope so aggregation runs against
+                        // the same documents the page was built from, not the current page.
+                        // A look-ahead on the selection set turns the requested ops/fields into
+                        // store specs, so only what was selected is computed.
+                        resolve: async (source, _args, ctx, info)=>{
+                            const scope = source.aggregateScope;
+                            const { count, aggregates } = this._buildAggregateRequest(id, info);
+                            return await ctx.resolveAggregate(scope.modelIDs, {
+                                filter: scope.filter,
+                                owner: scope.owner,
+                                catalogID: scope.catalogID,
+                                count,
+                                aggregates
+                            });
+                        }
+                    }
+                };
+                // Grouped aggregates only exist for models with at least one groupable scalar
+                // field (see _buildGroupedAggregate). Skip the field entirely otherwise so the
+                // schema does not reference empty GroupKeys/GroupBy/GroupKeysOrderBy types.
+                if (groupedAggregateType != null) {
+                    fields.groupedAggregates = {
+                        type: new GraphQLNonNull(toOuputList(groupedAggregateType)),
+                        args: {
+                            groupBy: {
+                                type: new GraphQLNonNull(toList(this._inputObjects[`${id}-group-by`]))
+                            },
+                            having: {
+                                type: this._inputObjects[`${id}-having`]
+                            },
+                            orderBy: {
+                                type: toList(this._inputObjects[`${id}-group-order`])
+                            },
+                            limit: {
+                                type: GraphQLInt
+                            }
+                        },
+                        // Translates the field arguments and the selection-set look-ahead into a
+                        // single grouped store request, scoped to the same documents the page was
+                        // built from, then returns the merged groups for the child resolvers to map.
+                        resolve: async (source, args, ctx, info)=>{
+                            const scope = source.aggregateScope;
+                            const { count, aggregates } = this._buildGroupedAggregateRequest(id, info);
+                            const groupBy = (args.groupBy ?? []).map((field)=>({
+                                    keys: [
+                                        field
+                                    ]
+                                }));
+                            const orderBy = this._buildGroupOrderBy(id, args.orderBy);
+                            return await ctx.resolveGroupedAggregate(scope.modelIDs, {
+                                filter: scope.filter,
+                                owner: scope.owner,
+                                catalogID: scope.catalogID,
+                                count,
+                                aggregates,
+                                groupBy,
+                                having: args.having,
+                                orderBy: orderBy.length > 0 ? orderBy : undefined,
+                                limit: args.limit ?? undefined
+                            });
+                        }
+                    };
+                }
+                return fields;
+            }
+        });
+        this._types[id] = nodeType;
+        this._types[`${id}-connection`] = connectionType;
+        this._types[`${id}-edge`] = edgeType;
+        this._buildDocumentDataObject(id, model, name);
+        this._buildDocumentInput(id, model);
+        this._buildObjectFilterInput(id, model.schema, name, true);
+        this._buildObjectOrderByInput(id, model.schema, name, true);
+        // TODO: move to dedicated method
+        if (!isInterface && this._includeMutations) {
+            if (model.behavior === 'default') {
+                this._mutations[`create${name}`] = mutationWithClientMutationId({
+                    name: `Create${name}`,
+                    inputFields: ()=>({
+                            data: {
+                                type: new GraphQLNonNull(this._inputObjects[id])
+                            },
+                            transactionID: {
+                                type: GraphQLID
+                            }
+                        }),
+                    outputFields: ()=>({
+                            ...definitions.queryFields,
+                            document: {
+                                type: this._types[id]
+                            }
+                        }),
+                    mutateAndGetPayload: async (input, ctx, info)=>{
+                        const document = await ctx.executeCreateMutation({
+                            modelID: id,
+                            data: input.data,
+                            info,
+                            transactionID: input.transactionID
+                        });
+                        return {
+                            document
+                        };
+                    }
+                });
+            } else if (model.behavior === 'unique') {
+                this._mutations[`set${name}`] = mutationWithClientMutationId({
+                    name: `Set${name}`,
+                    inputFields: ()=>({
+                            data: {
+                                type: new GraphQLNonNull(this._inputObjects[id])
+                            },
+                            transactionID: {
+                                type: GraphQLID
+                            }
+                        }),
+                    outputFields: ()=>({
+                            ...definitions.queryFields,
+                            document: {
+                                type: this._types[id]
+                            }
+                        }),
+                    mutateAndGetPayload: async (input, ctx, info)=>{
+                        const unique = getUniqueDocValue(model.uniqueFields, input.data);
+                        const document = await ctx.executeSetMutation({
+                            modelID: id,
+                            unique,
+                            data: input.data,
+                            info,
+                            transactionID: input.transactionID
+                        });
+                        return {
+                            document
+                        };
+                    }
+                });
+            }
+            this._mutations[`update${name}`] = mutationWithClientMutationId({
+                name: `Update${name}`,
+                inputFields: ()=>({
+                        id: {
+                            type: new GraphQLNonNull(GraphQLID)
+                        },
+                        patch: {
+                            type: new GraphQLNonNull(toList(PatchOperation))
+                        },
+                        from: {
+                            type: this._inputObjects[`${id}-update`]
+                        },
+                        transactionID: {
+                            type: GraphQLID
+                        }
+                    }),
+                outputFields: ()=>({
+                        ...definitions.queryFields,
+                        document: {
+                            type: this._types[id]
+                        }
+                    }),
+                mutateAndGetPayload: async (input, ctx, info)=>{
+                    const document = await ctx.executeUpdateMutation({
+                        input,
+                        info,
+                        transactionID: input.transactionID
+                    });
+                    return {
+                        document
+                    };
+                }
+            });
+            this._mutations[`remove${name}`] = mutationWithClientMutationId({
+                name: `Remove${name}`,
+                inputFields: ()=>({
+                        id: {
+                            type: new GraphQLNonNull(GraphQLID)
+                        },
+                        transactionID: {
+                            type: GraphQLID
+                        }
+                    }),
+                outputFields: ()=>({
+                        ...definitions.queryFields,
+                        // Return id so it can be used with Relay's @deleteRecord directive
+                        id: {
+                            type: new GraphQLNonNull(GraphQLID)
+                        }
+                    }),
+                mutateAndGetPayload: async (input, ctx, info)=>{
+                    await ctx.executeRemoveMutation({
+                        id: input.id,
+                        info,
+                        transactionID: input.transactionID
+                    });
+                    return {
+                        id: input.id
+                    };
+                }
+            });
+        }
+        return nodeType;
+    }
+    /**
+   * Build the `<Model>Aggregate` type attached to the connection, exposing `count`
+   * plus per-field `sum`/`average`/`min`/`max` selections gated by field type.
+   *
+   * Eligibility follows what SQL can faithfully compute over JSON-extracted values:
+   * - sum/average: numeric fields only (integer, number).
+   * - min/max: numeric fields plus string/date fields (lexical for strings).
+   * Field-selection subtypes are only emitted when at least one field qualifies,
+   * since an object type with no fields is invalid GraphQL. `count` is always present.
+   */ _buildAggregate(id, model, name) {
+        const existing = this._types[`${id}-aggregate`];
+        if (existing != null) {
+            return existing;
+        }
+        // Resolve each property to its underlying scalar so we can classify it. Only
+        // direct scalar references are eligible; object/array fields are skipped.
+        const sumFields = {};
+        const minMaxFields = {};
+        // Field key -> numeric, consumed by the look-ahead resolver to tag each spec.
+        const numericByKey = new Map();
+        for (const [key, value] of Object.entries(model.schema.properties ?? {})){
+            const ref = value.$ref;
+            if (ref == null) continue;
+            const refID = getReferenceID(ref);
+            const refSchema = this._getReferenceSchema(refID);
+            if (refSchema.type === 'object' || refSchema.type === 'array') continue;
+            const scalar = this._buildScalar(refID, refSchema);
+            const isNumeric = scalar === GraphQLInt || scalar === GraphQLFloat;
+            // Only plain-string formats (date / time / date-time, which map to GraphQLString)
+            // are min/max-eligible; custom-scalar formats (duration / email / uri) and enums
+            // are intentionally excluded from min/max.
+            const isStringLike = scalar === GraphQLString;
+            if (isNumeric) {
+                // sum keeps the field's own numeric type (Int stays Int, number is Float).
+                sumFields[key] = {
+                    type: scalar
+                };
+            }
+            if (isNumeric || isStringLike) {
+                minMaxFields[key] = {
+                    type: scalar
+                };
+                numericByKey.set(key, isNumeric);
+            }
+        }
+        this._aggregateNumericByModel[id] = numericByKey;
+        const numericKeys = Object.keys(sumFields);
+        // The aggregates connection resolver returns an AggregateValues; each op
+        // reads its slice from that source. Defaulting count to 0 keeps the non-null
+        // contract when a count was not requested by the look-ahead.
+        const aggregateFields = {
+            count: {
+                type: new GraphQLNonNull(GraphQLInt),
+                resolve: (source)=>source.count ?? 0
+            }
+        };
+        if (numericKeys.length > 0) {
+            const sumType = new GraphQLObjectType({
+                name: `${name}SumFields`,
+                fields: sumFields
+            });
+            // Average of integers is fractional, so every average field is Float.
+            const avgFields = {};
+            for (const key of numericKeys){
+                avgFields[key] = {
+                    type: GraphQLFloat
+                };
+            }
+            const avgType = new GraphQLObjectType({
+                name: `${name}AvgFields`,
+                fields: avgFields
+            });
+            this._types[`${id}-aggregate-sum`] = sumType;
+            this._types[`${id}-aggregate-avg`] = avgType;
+            // The *Fields child reads each field key off the returned Record via the
+            // default field resolver (e.g. SumFields.delta -> source.delta).
+            aggregateFields.sum = {
+                type: sumType,
+                resolve: (source)=>source.sum ?? null
+            };
+            aggregateFields.average = {
+                type: avgType,
+                resolve: (source)=>source.average ?? null
+            };
+        }
+        if (Object.keys(minMaxFields).length > 0) {
+            // min and max expose the identical field set, so they share one object type.
+            const minMaxType = new GraphQLObjectType({
+                name: `${name}MinMaxFields`,
+                fields: minMaxFields
+            });
+            this._types[`${id}-aggregate-min-max`] = minMaxType;
+            aggregateFields.min = {
+                type: minMaxType,
+                resolve: (source)=>source.min ?? null
+            };
+            aggregateFields.max = {
+                type: minMaxType,
+                resolve: (source)=>source.max ?? null
+            };
+        }
+        const aggregateType = new GraphQLObjectType({
+            name: `${name}Aggregate`,
+            fields: aggregateFields
+        });
+        this._types[`${id}-aggregate`] = aggregateType;
+        return aggregateType;
+    }
+    /**
+   * Build the grouped-aggregate type surface for a model, reusing the v1
+   * `<Model>SumFields` / `AvgFields` / `MinMaxFields` types from
+   * `_buildAggregate` and the existing value-filter / `OrderByDirection` inputs.
+   *
+   * Groupable fields are every property resolving to a scalar (object/array fields
+   * excluded), which is broader than aggregate eligibility: boolean and enum fields
+   * can be grouped on but never summed. The sum/average and min/max sub-shapes are
+   * only emitted when the model actually has those eligible fields, matching the
+   * conditionals in `_buildAggregate`, since an object type with no fields is invalid.
+   *
+   * Produces, registered in `_types` / `_inputObjects`:
+   * `<Model>GroupBy` enum, `<Model>GroupKeys`, `<Model>GroupedAggregate`,
+   * `<Model>Having` (+ `HavingSum`/`HavingAverage`/`HavingMin`/`HavingMax`),
+   * `<Model>GroupOrderBy` (+ `GroupKeysOrderBy` and per-op `<Op>FieldsOrderBy`).
+   */ _buildGroupedAggregate(id, model, name) {
+        const existing = this._types[`${id}-grouped-aggregate`];
+        if (existing != null) {
+            return existing;
+        }
+        // Every scalar property is groupable (object/array excluded), so this set is a
+        // superset of the aggregate-eligible fields, additionally covering boolean/enum.
+        const groupableTypes = new Map();
+        const groupKeyNumeric = new Map();
+        for (const [key, value] of Object.entries(model.schema.properties ?? {})){
+            const ref = value.$ref;
+            if (ref == null) continue;
+            const refID = getReferenceID(ref);
+            const refSchema = this._getReferenceSchema(refID);
+            if (refSchema.type === 'object' || refSchema.type === 'array') continue;
+            const scalar = this._buildScalar(refID, refSchema);
+            groupableTypes.set(key, scalar);
+            groupKeyNumeric.set(key, scalar === GraphQLInt || scalar === GraphQLFloat);
+        }
+        this._groupKeyNumericByModel[id] = groupKeyNumeric;
+        // GraphQL forbids empty object/input/enum types, so skip the whole grouped-aggregate
+        // surface (GroupKeys, GroupBy, GroupKeysOrderBy, GroupedAggregate, Having, GroupOrderBy)
+        // when no groupable scalar field exists — typical for tag-style models whose only
+        // properties are document references.
+        if (groupableTypes.size === 0) {
+            return null;
+        }
+        const sumType = this._types[`${id}-aggregate-sum`];
+        const avgType = this._types[`${id}-aggregate-avg`];
+        const minMaxType = this._types[`${id}-aggregate-min-max`];
+        // GroupBy enum: one value per groupable field key.
+        const groupByValues = {};
+        for (const key of groupableTypes.keys()){
+            groupByValues[key] = {
+                value: key
+            };
+        }
+        const groupByEnum = new GraphQLEnumType({
+            name: `${name}GroupBy`,
+            values: groupByValues
+        });
+        this._types[`${id}-group-by`] = groupByEnum;
+        this._inputObjects[`${id}-group-by`] = groupByEnum;
+        // GroupKeys: every groupable field, each nullable since a group may bucket
+        // documents missing the field into a null key.
+        const groupKeysFields = {};
+        for (const [key, scalar] of groupableTypes){
+            groupKeysFields[key] = {
+                type: scalar
+            };
+        }
+        const groupKeysType = new GraphQLObjectType({
+            name: `${name}GroupKeys`,
+            fields: groupKeysFields
+        });
+        this._types[`${id}-group-keys`] = groupKeysType;
+        // GroupedAggregate: the per-group keys plus count, reusing the v1 aggregate field
+        // types for sum/average/min/max under the same conditionals as `_buildAggregate`.
+        // Each op resolves its slice off the returned group; the *Fields / GroupKeys
+        // leaves keep the default resolver. Defaulting count to 0 and field ops to null
+        // mirrors `_buildAggregate` so the non-null contracts hold on missing slices.
+        const groupedFields = {
+            keys: {
+                type: new GraphQLNonNull(groupKeysType),
+                resolve: (group)=>group.keys
+            },
+            count: {
+                type: new GraphQLNonNull(GraphQLInt),
+                resolve: (group)=>group.count ?? 0
+            }
+        };
+        if (sumType != null && avgType != null) {
+            groupedFields.sum = {
+                type: sumType,
+                resolve: (group)=>group.sum ?? null
+            };
+            groupedFields.average = {
+                type: avgType,
+                resolve: (group)=>group.average ?? null
+            };
+        }
+        if (minMaxType != null) {
+            groupedFields.min = {
+                type: minMaxType,
+                resolve: (group)=>group.min ?? null
+            };
+            groupedFields.max = {
+                type: minMaxType,
+                resolve: (group)=>group.max ?? null
+            };
+        }
+        const groupedAggregateType = new GraphQLObjectType({
+            name: `${name}GroupedAggregate`,
+            fields: groupedFields
+        });
+        this._types[`${id}-grouped-aggregate`] = groupedAggregateType;
+        // Map a scalar to its existing value-filter input by name (IntValueFilter etc.).
+        const valueFilterFor = (scalar)=>{
+            return this._inputObjects[`${scalar.name}ValueFilter`];
+        };
+        // Having: each op maps its eligible fields to the value filter matching the op's
+        // scalar. Sum keeps each numeric field's own scalar; average is always Float;
+        // min/max keep each field's own scalar (Int / Float / String).
+        const havingFields = {
+            count: {
+                type: this._inputObjects.IntValueFilter
+            }
+        };
+        if (sumType != null && avgType != null) {
+            const havingSumFields = {};
+            const havingAvgFields = {};
+            for (const [key, field] of Object.entries(sumType.getFields())){
+                havingSumFields[key] = {
+                    type: valueFilterFor(field.type)
+                };
+                havingAvgFields[key] = {
+                    type: this._inputObjects.FloatValueFilter
+                };
+            }
+            const havingSum = new GraphQLInputObjectType({
+                name: `${name}HavingSum`,
+                fields: havingSumFields
+            });
+            const havingAvg = new GraphQLInputObjectType({
+                name: `${name}HavingAverage`,
+                fields: havingAvgFields
+            });
+            this._inputObjects[`${id}-having-sum`] = havingSum;
+            this._inputObjects[`${id}-having-average`] = havingAvg;
+            havingFields.sum = {
+                type: havingSum
+            };
+            havingFields.average = {
+                type: havingAvg
+            };
+        }
+        if (minMaxType != null) {
+            const havingMinFields = {};
+            const havingMaxFields = {};
+            for (const [key, field] of Object.entries(minMaxType.getFields())){
+                havingMinFields[key] = {
+                    type: valueFilterFor(field.type)
+                };
+                havingMaxFields[key] = {
+                    type: valueFilterFor(field.type)
+                };
+            }
+            const havingMin = new GraphQLInputObjectType({
+                name: `${name}HavingMin`,
+                fields: havingMinFields
+            });
+            const havingMax = new GraphQLInputObjectType({
+                name: `${name}HavingMax`,
+                fields: havingMaxFields
+            });
+            this._inputObjects[`${id}-having-min`] = havingMin;
+            this._inputObjects[`${id}-having-max`] = havingMax;
+            havingFields.min = {
+                type: havingMin
+            };
+            havingFields.max = {
+                type: havingMax
+            };
+        }
+        const havingInput = new GraphQLInputObjectType({
+            name: `${name}Having`,
+            fields: havingFields
+        });
+        this._inputObjects[`${id}-having`] = havingInput;
+        // GroupOrderBy: every leaf orders by the shared OrderByDirection enum. The keys
+        // sub-input covers all groupable fields; each op sub-input mirrors that op's
+        // aggregate field map, emitted only when the op's fields exist.
+        const buildDirectionInput = (subName, keys)=>{
+            const fields = {};
+            for (const key of keys){
+                fields[key] = {
+                    type: OrderByDirection
+                };
+            }
+            return new GraphQLInputObjectType({
+                name: subName,
+                fields
+            });
+        };
+        const groupKeysOrderBy = buildDirectionInput(`${name}GroupKeysOrderBy`, groupableTypes.keys());
+        this._inputObjects[`${id}-group-keys-order`] = groupKeysOrderBy;
+        const groupOrderByFields = {
+            keys: {
+                type: groupKeysOrderBy
+            },
+            count: {
+                type: OrderByDirection
+            }
+        };
+        if (sumType != null && avgType != null) {
+            const sumOrderBy = buildDirectionInput(`${name}SumFieldsOrderBy`, Object.keys(sumType.getFields()));
+            const avgOrderBy = buildDirectionInput(`${name}AvgFieldsOrderBy`, Object.keys(avgType.getFields()));
+            this._inputObjects[`${id}-sum-order`] = sumOrderBy;
+            this._inputObjects[`${id}-avg-order`] = avgOrderBy;
+            groupOrderByFields.sum = {
+                type: sumOrderBy
+            };
+            groupOrderByFields.average = {
+                type: avgOrderBy
+            };
+        }
+        if (minMaxType != null) {
+            const minOrderBy = buildDirectionInput(`${name}MinFieldsOrderBy`, Object.keys(minMaxType.getFields()));
+            const maxOrderBy = buildDirectionInput(`${name}MaxFieldsOrderBy`, Object.keys(minMaxType.getFields()));
+            this._inputObjects[`${id}-min-order`] = minOrderBy;
+            this._inputObjects[`${id}-max-order`] = maxOrderBy;
+            groupOrderByFields.min = {
+                type: minOrderBy
+            };
+            groupOrderByFields.max = {
+                type: maxOrderBy
+            };
+        }
+        const groupOrderBy = new GraphQLInputObjectType({
+            name: `${name}GroupOrderBy`,
+            fields: groupOrderByFields
+        });
+        this._inputObjects[`${id}-group-order`] = groupOrderBy;
+        return groupedAggregateType;
+    }
+    /**
+   * Inspect the selection set under the `aggregates` field to determine exactly
+   * which aggregation work to ask the store for: whether a count was selected,
+   * and for each of sum/average/min/max, which field subselections were
+   * requested. Field aggregates not selected are never computed, so a
+   * `{ count }`-only query issues `aggregates: []`.
+   *
+   * Reads the resolved field nodes via `info.fieldNodes`. Selections reached
+   * through fragment spreads and inline fragments are expanded transparently, so
+   * `aggregates { ...AggFields }`, `aggregates { ... { count } }` and
+   * `sum { ...SumFields }` all request the same work as their inlined forms.
+   */ _buildAggregateRequest(id, info) {
+        const numericByKey = this._aggregateNumericByModel[id] ?? new Map();
+        const ops = [
+            'sum',
+            'average',
+            'min',
+            'max'
+        ];
+        let count = false;
+        const aggregates = [];
+        for (const fieldNode of info.fieldNodes){
+            const selections = fieldNode.selectionSet?.selections ?? [];
+            for (const selection of this._expandFieldSelections(selections, info, new Set())){
+                const fieldName = selection.name.value;
+                if (fieldName === 'count') {
+                    count = true;
+                    continue;
+                }
+                if (!ops.includes(fieldName)) continue;
+                const op = fieldName;
+                const opSelections = selection.selectionSet?.selections ?? [];
+                for (const opSelection of this._expandFieldSelections(opSelections, info, new Set())){
+                    const key = opSelection.name.value;
+                    // For a top-level scalar field the JSON path is just the field key.
+                    aggregates.push({
+                        op,
+                        keys: [
+                            key
+                        ],
+                        numeric: numericByKey.get(key) ?? false
+                    });
+                }
+            }
+        }
+        return {
+            count,
+            aggregates
+        };
+    }
+    /**
+   * Inspect the selection set under the `groupedAggregates` field to determine the
+   * aggregation work to ask the store for. The aggregate ops (`count`/`sum`/
+   * `average`/`min`/`max`) are nested directly under the field alongside `keys`,
+   * which is skipped here since it is shaped by the `groupBy` argument, not the
+   * selection. Fragment spreads and inline fragments are expanded transparently.
+   * Selecting only `keys` and `count` yields `aggregates: []`.
+   */ _buildGroupedAggregateRequest(id, info) {
+        const numericByKey = this._aggregateNumericByModel[id] ?? new Map();
+        const ops = [
+            'sum',
+            'average',
+            'min',
+            'max'
+        ];
+        let count = false;
+        const aggregates = [];
+        for (const fieldNode of info.fieldNodes){
+            const selections = fieldNode.selectionSet?.selections ?? [];
+            for (const selection of this._expandFieldSelections(selections, info, new Set())){
+                const fieldName = selection.name.value;
+                if (fieldName === 'count') {
+                    count = true;
+                    continue;
+                }
+                // `keys` is driven by the groupBy argument, not the aggregate look-ahead.
+                if (fieldName === 'keys') continue;
+                if (!ops.includes(fieldName)) continue;
+                const op = fieldName;
+                const opSelections = selection.selectionSet?.selections ?? [];
+                for (const opSelection of this._expandFieldSelections(opSelections, info, new Set())){
+                    const key = opSelection.name.value;
+                    aggregates.push({
+                        op,
+                        keys: [
+                            key
+                        ],
+                        numeric: numericByKey.get(key) ?? false
+                    });
+                }
+            }
+        }
+        return {
+            count,
+            aggregates
+        };
+    }
+    /**
+   * Translate the `orderBy` argument entries into store ordering terms over each
+   * finalised group. Each entry's present leaves become a term whose `path`
+   * navigates the group object (`['count']`, `['keys', field]`, `['sum', field]`,
+   * etc.) and whose `numeric` flag drives arithmetic comparison. List order is
+   * preserved so earlier terms take precedence and later terms break ties.
+   */ _buildGroupOrderBy(id, orderBy) {
+        if (orderBy == null) return [];
+        const aggregateNumeric = this._aggregateNumericByModel[id] ?? new Map();
+        const groupKeyNumeric = this._groupKeyNumericByModel[id] ?? new Map();
+        const terms = [];
+        for (const entry of orderBy){
+            if (entry.count != null) {
+                terms.push({
+                    path: [
+                        'count'
+                    ],
+                    direction: entry.count,
+                    numeric: true
+                });
+            }
+            for (const [field, direction] of Object.entries(entry.keys ?? {})){
+                terms.push({
+                    path: [
+                        'keys',
+                        field
+                    ],
+                    direction,
+                    numeric: groupKeyNumeric.get(field) ?? false
+                });
+            }
+            for (const [field, direction] of Object.entries(entry.sum ?? {})){
+                terms.push({
+                    path: [
+                        'sum',
+                        field
+                    ],
+                    direction,
+                    numeric: aggregateNumeric.get(field) ?? false
+                });
+            }
+            for (const [field, direction] of Object.entries(entry.average ?? {})){
+                // Averages are always fractional, so they always compare numerically.
+                terms.push({
+                    path: [
+                        'average',
+                        field
+                    ],
+                    direction,
+                    numeric: true
+                });
+            }
+            for (const [field, direction] of Object.entries(entry.min ?? {})){
+                terms.push({
+                    path: [
+                        'min',
+                        field
+                    ],
+                    direction,
+                    numeric: aggregateNumeric.get(field) ?? false
+                });
+            }
+            for (const [field, direction] of Object.entries(entry.max ?? {})){
+                terms.push({
+                    path: [
+                        'max',
+                        field
+                    ],
+                    direction,
+                    numeric: aggregateNumeric.get(field) ?? false
+                });
+            }
+        }
+        return terms;
+    }
+    /**
+   * Walk a selection set and yield the underlying field nodes, expanding
+   * fragment spreads and inline fragments in place. The `visited` set tracks
+   * named fragments already entered so cyclic fragment references terminate.
+   */ *_expandFieldSelections(selections, info, visited) {
+        for (const selection of selections){
+            switch(selection.kind){
+                case Kind.FIELD:
+                    yield selection;
+                    break;
+                case Kind.INLINE_FRAGMENT:
+                    yield* this._expandFieldSelections(selection.selectionSet.selections, info, visited);
+                    break;
+                case Kind.FRAGMENT_SPREAD:
+                    {
+                        const fragmentName = selection.name.value;
+                        if (visited.has(fragmentName)) break;
+                        const fragment = info.fragments[fragmentName];
+                        if (fragment == null) break;
+                        visited.add(fragmentName);
+                        yield* this._expandFieldSelections(fragment.selectionSet.selections, info, visited);
+                        break;
+                    }
+            }
+        }
+    }
+    _buildDocumentFields(id, model, name) {
+        const dataObject = this._buildDocumentDataObject(id, model, name);
+        const definitions = this._getDefinitions();
+        const fields = {
+            ...definitions.documentNodeFields,
+            data: {
+                type: new GraphQLNonNull(dataObject)
+            }
+        };
+        for (const [key, field] of Object.entries(dataObject.getFields())){
+            const meta = model.fieldsMeta[key];
+            if (meta == null) {
+                continue;
+            }
+            switch(meta.type){
+                case 'account':
+                    {
+                        if (isList(field.type)) {
+                            fields[`${key}Accounts`] = {
+                                type: new GraphQLNonNull(toOuputList(definitions.accountObject)),
+                                resolve: (doc)=>doc.data?.[key] ?? []
+                            };
+                        } else {
+                            fields[`${key}Account`] = {
+                                type: definitions.accountObject,
+                                resolve: (doc)=>doc.data?.[key] ?? null
+                            };
+                        }
+                        break;
+                    }
+                case 'attachment':
+                    {
+                        if (isList(field.type)) {
+                            fields[`${key}Attachments`] = {
+                                type: new GraphQLNonNull(toOuputList(definitions.attachmentObject)),
+                                resolve: (doc)=>{
+                                    const ids = doc.data?.[key] ?? [];
+                                    return ids.map(AttachmentID.fromString);
+                                }
+                            };
+                        } else {
+                            fields[`${key}Attachment`] = {
+                                type: definitions.attachmentObject,
+                                resolve: (doc)=>{
+                                    const id = doc.data?.[key];
+                                    return id ? AttachmentID.fromString(id) : null;
+                                }
+                            };
+                        }
+                        break;
+                    }
+                case 'document':
+                    {
+                        const relationModel = meta.model;
+                        if (typeof relationModel === 'undefined') {
+                            continue;
+                        }
+                        let relationModelID;
+                        let relationType;
+                        if (relationModel === null) {
+                            relationModelID = null;
+                            relationType = definitions.documentInterface;
+                        } else {
+                            relationModelID = getGlobalID(relationModel, id).toString();
+                            // Check if the related model is included in the schema
+                            if (this._includedModelIDs.has(relationModelID)) {
+                                relationType = this._buildDocument(relationModelID);
+                            } else {
+                                // Fall back to generic DocumentNode interface
+                                relationType = definitions.documentInterface;
+                                relationModelID = null; // Treat as unspecified model
+                            }
+                        }
+                        if (isList(field.type)) {
+                            // TODO: add suport for filters?
+                            fields[`${key}Documents`] = {
+                                type: new GraphQLNonNull(toOuputList(relationType)),
+                                resolve: async (doc, _args, ctx)=>{
+                                    const relationIDs = doc.data?.[key] ?? [];
+                                    return relationIDs.length ? await ctx.resolveList(this.getModelIDs(relationModelID), relationIDs) : [];
+                                }
+                            };
+                        } else {
+                            fields[`${key}Document`] = {
+                                type: relationType,
+                                resolve: async (doc, _args, ctx)=>{
+                                    const relationID = doc.data?.[key];
+                                    return relationID ? await ctx.loadDocument(relationID) : null;
+                                }
+                            };
+                        }
+                        break;
+                    }
+            }
+        }
+        for (const iid of model.interfaces ?? []){
+            const interfaceID = getGlobalID(iid, id).toString();
+            for (const [fieldName, relations] of Object.entries(this._relationsTo[interfaceID] ?? {})){
+                for (const relation of relations){
+                    if (!this._includedModelIDs.has(relation.model)) continue;
+                    this._buildRelationFields(fields, fieldName, relation);
+                }
+            }
+        }
+        for (const [fieldName, relations] of Object.entries(this._relationsTo[id] ?? {})){
+            for (const relation of relations){
+                if (!this._includedModelIDs.has(relation.model)) continue;
+                this._buildRelationFields(fields, fieldName, relation);
+            }
+        }
+        return fields;
+    }
+    _buildDocumentDataObject(id, model, name) {
+        const typeID = `${id}-data`;
+        if (this._types[typeID] != null) {
+            return this._types[typeID];
+        }
+        const required = model.schema.required ?? [];
+        const fields = {};
+        for (const [key, value] of Object.entries(model.schema.properties ?? {})){
+            const fieldRef = value.$ref;
+            if (fieldRef == null) {
+                throw new Error(`Missing ref for field ${key} of object ${id}`);
+            }
+            const type = this._getReference(fieldRef);
+            fields[key] = {
+                type: required.includes(key) ? new GraphQLNonNull(type) : type
+            };
+        }
+        const config = {
+            name: `${name}Data`,
+            interfaces: ()=>{
+                return model.interfaces.map((interfaceID)=>{
+                    const typeID = `${getGlobalID(interfaceID, id).toString()}-data`;
+                    return this._types[typeID];
+                }).filter((type)=>type != null);
+            },
+            fields
+        };
+        const object = model.behavior === 'interface' ? new GraphQLInterfaceType(config) : new GraphQLObjectType(config);
+        this._types[typeID] = object;
+        return object;
+    }
+    _buildDocumentInput(id, model) {
+        if (model.behavior === 'interface') {
+            // No mutations for interfaces
+            return;
+        }
+        const setFields = {};
+        const updateFields = {};
+        for (const [key, value] of Object.entries(model.schema.properties)){
+            const path = value.$ref;
+            const setType = this._getReferenceInput(path, false);
+            setFields[key] = {
+                type: model.schema.required.includes(key) ? new GraphQLNonNull(setType) : setType
+            };
+            const id = getReferenceID(path);
+            const schema = this._getReferenceSchema(id);
+            if (schema.const == null) {
+                updateFields[key] = {
+                    type: this._getReferenceInput(path, true)
+                };
+            }
+        }
+        const name = this._aliases[id];
+        this._inputObjects[id] = new GraphQLInputObjectType({
+            name: `${name}Input`,
+            fields: setFields
+        });
+        this._inputObjects[`${id}-update`] = new GraphQLInputObjectType({
+            name: `Partial${name}Input`,
+            fields: updateFields
+        });
+    }
+    _buildReferenceFilterInput(path, parentName = '') {
+        const id = getReferenceID(path);
+        const schema = this._getReferenceSchema(id);
+        let refParentName = parentName;
+        if (schema.type === 'object') {
+            return schema.additionalProperties ? null : this._buildObjectFilterInput(id, schema, parentName);
+        }
+        if (schema.type === 'array') {
+            const name = this._aliases[id] ?? pascalCase(parentName + schema.title);
+            refParentName = name;
+            // const itemType = this._buildReferenceFilterInput(schema.items.$ref, schema.title)
+            return new GraphQLInputObjectType({
+                name: `${name}Filter`,
+                isOneOf: true,
+                fields: {
+                    // DB does not support filtering on array values
+                    // contains: { type: toList(itemType) },
+                    // isEmpty: { type: GraphQLBoolean },
+                    isNull: {
+                        type: GraphQLBoolean
+                    }
+                }
+            });
+        }
+        const scalar = this._buildScalar(id, schema, refParentName);
+        const knownFilter = VALUE_FILTER_INPUT_TYPES[scalar.name];
+        if (knownFilter != null) {
+            return this._inputObjects[knownFilter];
+        }
+        const filter = isEnumType(scalar) ? createEnumValueFilterInput(scalar) : createScalarValueFilterInput(scalar);
+        if (this._inputObjects[filter.name] == null) {
+            this._inputObjects[filter.name] = filter;
+        }
+        return this._inputObjects[filter.name];
+    }
+    _buildReferenceOrderByInput(path, parentName = '') {
+        const id = getReferenceID(path);
+        const schema = this._getReferenceSchema(id);
+        switch(schema.type){
+            case 'array':
+                return null;
+            case 'object':
+                return schema.additionalProperties ? null : this._buildObjectOrderByInput(id, schema, parentName);
+            default:
+                return OrderByDirection;
+        }
+    }
+    _buildObjectFilterInput(id, schema, parentName = '', isDocument = false) {
+        const inputID = `${id}-filter`;
+        const existing = this._inputObjects[inputID];
+        if (existing != null) {
+            return existing;
+        }
+        const name = this._aliases[id] ?? pascalCase(parentName + (schema.title ?? ''));
+        const fields = isDocument ? {
+            _owner: {
+                type: this._inputObjects.AccountValueFilter
+            }
+        } : {};
+        for (const [key, value] of Object.entries(schema.properties)){
+            const type = this._buildReferenceFilterInput(value.$ref, name);
+            if (type !== null) {
+                fields[key] = {
+                    type
+                };
+            }
+        }
+        const objectInput = new GraphQLInputObjectType({
+            name: `${name}ObjectFilter`,
+            fields
+        });
+        const input = new GraphQLInputObjectType({
+            name: `${name}Filter`,
+            isOneOf: true,
+            fields: ()=>({
+                    where: {
+                        type: objectInput
+                    },
+                    and: {
+                        type: toList(this._inputObjects[inputID])
+                    },
+                    or: {
+                        type: toList(this._inputObjects[inputID])
+                    },
+                    not: {
+                        type: this._inputObjects[inputID]
+                    }
+                })
+        });
+        this._inputObjects[inputID] = input;
+        return input;
+    }
+    _buildObjectOrderByInput(id, schema, parentName = '', isDocument = false) {
+        const inputID = `${id}-order`;
+        const existing = this._inputObjects[inputID];
+        if (existing != null) {
+            return existing;
+        }
+        const name = this._aliases[id] ?? pascalCase(parentName + (schema.title ?? ''));
+        const fields = isDocument ? {
+            _docOwner: {
+                type: OrderByDirection
+            },
+            _createdAt: {
+                type: OrderByDirection
+            }
+        } : {};
+        for (const [key, value] of Object.entries(schema.properties)){
+            const type = this._buildReferenceOrderByInput(value.$ref, name);
+            if (type != null) {
+                fields[key] = {
+                    type
+                };
+            }
+        }
+        const input = new GraphQLInputObjectType({
+            name: `${name}OrderBy`,
+            isOneOf: true,
+            fields
+        });
+        this._inputObjects[inputID] = input;
+        return input;
+    }
+    _buildSetInputObjectType(id, withFields, relationField) {
+        const relationFieldName = relationField ? pascalCase(relationField) : '';
+        const inputID = `${id}-with-${relationFieldName}`;
+        const existing = this._inputObjects[inputID];
+        if (existing != null) {
+            return existing;
+        }
+        const model = this._record[id];
+        const name = this._aliases[id];
+        this._inputObjects[inputID] = new GraphQLInputObjectType({
+            name: `With${relationFieldName}${name}Input`,
+            fields: ()=>{
+                const fields = {};
+                for (const fieldName of withFields){
+                    const field = model.schema.properties[fieldName];
+                    if (field == null) {
+                        throw new Error(`Field ${fieldName} not found on model ${name}`);
+                    }
+                    const type = this._getReferenceInput(field.$ref, false);
+                    fields[fieldName] = {
+                        type: new GraphQLNonNull(type)
+                    };
+                }
+                return fields;
+            }
+        });
+        return this._inputObjects[inputID];
+    }
+    _buildReference(id, schema, parentName = '') {
+        if (this._types[id] != null) {
+            return this._types[id];
+        }
+        switch(schema.type){
+            case 'array':
+                this._types[id] = this._buildArray(schema, parentName);
+                return this._types[id];
+            case 'object':
+                this._types[id] = schema.additionalProperties ? GraphQLJSONObject : this._buildObject(id, schema, parentName);
+                return this._types[id];
+            default:
+                return this._buildScalar(id, schema, parentName);
+        }
+    }
+    _buildScalar(id, schema, parentName = '') {
+        if (this._types[id] != null) {
+            return this._types[id];
+        }
+        switch(schema.type){
+            case 'boolean':
+                this._types[id] = GraphQLBoolean;
+                break;
+            case 'integer':
+                this._types[id] = GraphQLInt;
+                break;
+            case 'number':
+                this._types[id] = GraphQLFloat;
+                break;
+            case 'string':
+                this._types[id] = this._buildString(schema, parentName);
+                break;
+        }
+        return this._types[id];
+    }
+    _buildArray(schema, parentName = '') {
+        const itemRef = schema.items.$ref;
+        return new GraphQLList(new GraphQLNonNull(this._getReference(itemRef, pascalCase(parentName + schema.title))));
+    }
+    _buildObject(id, schema, parentName = '') {
+        const name = pascalCase(parentName + schema.title);
+        const fields = this._buildObjectFields(id, schema, name);
+        return new GraphQLObjectType({
+            name,
+            fields
+        });
+    }
+    _buildObjectFields(id, schema, parentName = '') {
+        const required = schema.required ?? [];
+        const fields = {};
+        for (const [key, value] of Object.entries(schema.properties ?? {})){
+            const fieldRef = value.$ref;
+            if (fieldRef == null) {
+                throw new Error(`Missing ref for field ${key} of object ${id}`);
+            }
+            const type = this._getReference(fieldRef, parentName);
+            fields[key] = {
+                type: required.includes(key) ? new GraphQLNonNull(type) : type
+            };
+        }
+        return fields;
+    }
+    _buildRelationFields(fields, fieldName, relation) {
+        if (relation.isList) {
+            // DB does not support matches for array containing values
+            return;
+        }
+        const relationID = relation.model;
+        const relationName = `${pascalCase(fieldName)}Of${this._aliases[relationID]}`;
+        fields[`in${relationName}`] = {
+            type: new GraphQLNonNull(this._types[`${relationID}-connection`]),
+            args: {
+                ...connectionArgs,
+                filter: {
+                    type: this._inputObjects[`${relationID}-filter`]
+                },
+                orderBy: {
+                    type: toList(this._inputObjects[`${relationID}-order`])
+                }
+            },
+            resolve: (doc, args, ctx)=>{
+                const docFilter = {
+                    where: {
+                        [fieldName]: {
+                            equalTo: doc.id
+                        }
+                    }
+                };
+                const filter = args.filter ? {
+                    and: [
+                        args.filter,
+                        docFilter
+                    ]
+                } : docFilter;
+                return ctx.resolveConnection(this.getModelIDs(relationID), {
+                    ...args,
+                    filter
+                });
+            }
+        };
+    }
+    _buildRelationSubscriptions(fields, modelID, fieldName, relation) {
+        if (relation.isList) {
+            // Inverse relations to list fields are not supported in connections so we skip them for subscriptions as well
+            return;
+        }
+        const targetFieldName = pascalCase(fieldName);
+        fields[`edge${this._aliases[relation.model]}AddedAs${targetFieldName}To${this._aliases[modelID]}`] = {
+            type: new GraphQLNonNull(this._types[`${relation.model}-edge`]),
+            args: {
+                id: {
+                    type: new GraphQLNonNull(GraphQLID)
+                }
+            },
+            resolve: (edge)=>edge,
+            subscribe: (_src, args, ctx)=>{
+                return ctx.subscribeToDocumentEdgeAdded(this.getModelIDs(relation.model), (data)=>data[fieldName] === args.id);
+            }
+        };
+        fields[`edge${this._aliases[relation.model]}RemovedAs${targetFieldName}From${this._aliases[modelID]}`] = {
+            type: new GraphQLNonNull(GraphQLID),
+            args: {
+                id: {
+                    type: new GraphQLNonNull(GraphQLID)
+                }
+            },
+            resolve: (id)=>id,
+            subscribe: (_src, args, ctx)=>{
+                return ctx.subscribeToDocumentEdgeRemoved(this.getModelIDs(relation.model), (data)=>data[fieldName] === args.id);
+            }
+        };
+    }
+    _buildString(schema, parentName) {
+        if (schema.const != null) {
+            return GraphQLString;
+        }
+        if (schema.enum != null) {
+            return this._buildEnumString(schema, parentName);
+        }
+        if (schema.format != null) {
+            return this._buildFormatString(schema);
+        }
+        return this._buildCustomString(schema);
+    }
+    _buildCustomString(schema) {
+        if (schema.title == null) {
+            // Plain string type
+            return GraphQLString;
+        }
+        const title = schema.title.toLowerCase();
+        return STRING_TITLES[title] ?? GraphQLString;
+    }
+    _buildEnumString(schema, parentName = '') {
+        const name = pascalCase(parentName + schema.title);
+        const typeName = `${name}-enum`;
+        if (this._types[typeName] == null) {
+            const values = {};
+            for (const value of schema.enum){
+                values[value] = {
+                    value
+                };
+            }
+            this._types[typeName] = new GraphQLEnumType({
+                name,
+                values
+            });
+        }
+        return this._types[typeName];
+    }
+    _buildFormatString(schema) {
+        const scalar = STRING_FORMATS[schema.format];
+        if (scalar == null) {
+            throw new Error(`Unsupported string format: ${schema.format}`);
+        }
+        return scalar;
+    }
+}
+export function createSchema(params) {
+    return new SchemaBuilder(params).build();
+}