@kubun/graphql 0.4.4 → 0.5.0

package/lib/schema.js

@@ -1,1202 +1 @@
-import { AttachmentID, DocumentID, DocumentModelID, decodeID } from '@kubun/id';
-import { REFERENCE_PREFIX } from '@kubun/protocol';
-import { pascalCase } from 'change-case';
-import { GraphQLBoolean, GraphQLEnumType, GraphQLFloat, GraphQLID, GraphQLInputObjectType, GraphQLInt, GraphQLInterfaceType, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLSchema, GraphQLString, isEnumType, isListType, isNonNullType } from 'graphql';
-import { connectionArgs, connectionDefinitions, mutationWithClientMutationId, nodeDefinitions } from 'graphql-relay';
-import { GraphQLDateTimeISO, GraphQLDID, GraphQLDuration, GraphQLEmailAddress, GraphQLJSON, GraphQLJSONObject, GraphQLURL } from 'graphql-scalars';
-import { GraphQLAttachmentID, GraphQLDocID } from './identifiers.js';
-import { getUniqueDocValue } from './utils.js';
-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'
-        }
-    }
-});
-export class SchemaBuilder {
-    // Mapping of model or references IDs to their GraphQL object names
-    _aliases;
-    _definitions;
-    _implemented = {};
-    _inputObjects = {
-        ...VALUE_FILTER_INPUTS,
-        PatchOperation
-    };
-    _mutations = {};
-    _nodeModelIDs;
-    _record;
-    _references = {};
-    _relationsTo = {};
-    _subscriptions = {};
-    _types = {
-        OrderByDirection
-    };
-    constructor(params){
-        this._aliases = params.aliases ?? {};
-        this._record = params.record;
-        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);
-    }
-    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 Object.keys(this._record)){
-            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`])
-                    }
-                },
-                resolve: async (_, args, ctx)=>{
-                    return await ctx.resolveConnection(this.getModelIDs(id), args);
-                }
-            };
-        }
-        return new GraphQLSchema({
-            query: new GraphQLObjectType({
-                name: 'Query',
-                fields: queryFields
-            }),
-            mutation: new GraphQLObjectType({
-                name: 'Mutation',
-                fields: this._mutations
-            }),
-            subscription: new GraphQLObjectType({
-                name: 'Subscription',
-                fields: ()=>{
-                    const fields = {
-                        documentChanged: {
-                            type: new GraphQLNonNull(definitions.documentInterface),
-                            args: {
-                                id: {
-                                    type: new GraphQLNonNull(GraphQLID)
-                                }
-                            },
-                            resolve: (doc)=>doc,
-                            subscribe: (_, args, ctx)=>{
-                                return ctx.subscribeToDocumentChanged(args.id);
-                            }
-                        },
-                        documentRemoved: {
-                            type: new GraphQLNonNull(GraphQLID),
-                            resolve: (id)=>id,
-                            subscribe: (_src, _args, ctx)=>{
-                                return ctx.subscribeToDocumentRemoved();
-                            }
-                        }
-                    };
-                    for (const [id, model] of Object.entries(this._record)){
-                        const name = this._aliases[id];
-                        fields[`new${name}Created`] = {
-                            type: new GraphQLNonNull(this._types[id]),
-                            resolve: (doc)=>doc,
-                            subscribe: (_src, _args, ctx)=>{
-                                return ctx.subscribeToDocumentCreated(this.getModelIDs(id));
-                            }
-                        };
-                        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){
-                                this._buildRelationSubscriptions(fields, id, fieldName, relation);
-                            }
-                        }
-                    }
-                    return fields;
-                }
-            })
-        });
-    }
-    _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);
-            }
-            throw new Error(`Unsupported node ID: ${id}`);
-        }, (node)=>{
-            return typeof node === 'string' ? 'AccountNode' : node instanceof AttachmentID ? 'AttachmentNode' : this._aliases[node.model];
-        });
-        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)){
-                    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
-            }
-        };
-        const documentInterface = new GraphQLInterfaceType({
-            name: 'DocumentNode',
-            interfaces: [
-                nodeDefs.nodeInterface
-            ],
-            fields: documentNodeFields
-        });
-        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()];
-                }));
-            },
-            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 { connectionType, edgeType } = connectionDefinitions({
-            nodeType
-        });
-        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) {
-            if (model.behavior === 'default') {
-                this._mutations[`create${name}`] = mutationWithClientMutationId({
-                    name: `Create${name}`,
-                    inputFields: ()=>({
-                            data: {
-                                type: new GraphQLNonNull(this._inputObjects[id])
-                            }
-                        }),
-                    outputFields: ()=>({
-                            ...definitions.queryFields,
-                            document: {
-                                type: this._types[id]
-                            }
-                        }),
-                    mutateAndGetPayload: async (input, ctx, info)=>{
-                        const document = await ctx.executeCreateMutation(id, input.data, info);
-                        return {
-                            document
-                        };
-                    }
-                });
-            } else if (model.behavior === 'unique') {
-                this._mutations[`set${name}`] = mutationWithClientMutationId({
-                    name: `Set${name}`,
-                    inputFields: ()=>({
-                            data: {
-                                type: new GraphQLNonNull(this._inputObjects[id])
-                            }
-                        }),
-                    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(id, unique, input.data, info);
-                        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`]
-                        }
-                    }),
-                outputFields: ()=>({
-                        ...definitions.queryFields,
-                        document: {
-                            type: this._types[id]
-                        }
-                    }),
-                mutateAndGetPayload: async (input, ctx, info)=>{
-                    const document = await ctx.executeUpdateMutation(input, info);
-                    return {
-                        document
-                    };
-                }
-            });
-            this._mutations[`remove${name}`] = mutationWithClientMutationId({
-                name: `Remove${name}`,
-                inputFields: ()=>({
-                        id: {
-                            type: new GraphQLNonNull(GraphQLID)
-                        }
-                    }),
-                outputFields: ()=>definitions.queryFields,
-                mutateAndGetPayload: async (input, ctx, info)=>{
-                    await ctx.executeRemoveMutation(input.id, info);
-                    return {};
-                }
-            });
-        }
-        return nodeType;
-    }
-    _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();
-                            relationType = this._buildDocument(relationModelID);
-                        }
-                        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){
-                    this._buildRelationFields(fields, fieldName, relation);
-                }
-            }
-        }
-        for (const [fieldName, relations] of Object.entries(this._relationsTo[id] ?? {})){
-            for (const relation of relations){
-                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];
-                });
-            },
-            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
-                });
-            }
-        };
-    // TODO: add support for count relation
-    // fields[`_${fieldName}_of_${relationName}_count`] = {
-    //   type: new GraphQLNonNull(GraphQLInt),
-    // }
-    }
-    _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(record, aliases) {
-    return new SchemaBuilder({
-        record,
-        aliases
-    }).build();
-}
+import{AttachmentID as e,DocumentID as t,DocumentModelID as i,decodeID as n}from"@kubun/id";import{REFERENCE_PREFIX as s}from"@kubun/protocol";import{pascalCase as l}from"change-case";import{GraphQLBoolean as r,GraphQLEnumType as o,GraphQLFloat as a,GraphQLID as u,GraphQLInputObjectType as d,GraphQLInt as c,GraphQLInterfaceType as p,GraphQLList as h,GraphQLNonNull as f,GraphQLObjectType as m,GraphQLSchema as y,GraphQLString as _,isEnumType as b,isListType as w,isNonNullType as g}from"graphql";import{connectionArgs as D,connectionDefinitions as I,mutationWithClientMutationId as O,nodeDefinitions as $}from"graphql-relay";import{GraphQLDateTimeISO as j,GraphQLDID as v,GraphQLDuration as S,GraphQLEmailAddress as M,GraphQLJSON as F,GraphQLJSONObject as T,GraphQLURL as R}from"graphql-scalars";import{GraphQLAttachmentID as A,GraphQLDocID as L}from"./identifiers.js";import{getUniqueDocValue as q}from"./utils.js";let P={date:_,time:_,"date-time":_,duration:S,email:M,uri:R},E={attachmentid:A,did:v,docid:L};function G(e){return e.slice(s.length)}function C(e){return w(e)||g(e)&&w(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 h(new f(e))}export function toOuputList(e){return new h(new f(e))}function V(e){return new d({name:`${e.name}ValueFilter`,isOneOf:!0,fields:{isNull:{type:r},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 x={AccountValueFilter:new d({name:"AccountValueFilter",isOneOf:!0,fields:{equalTo:{type:v},notEqualTo:{type:v},in:{type:toList(v)},notIn:{type:toList(v)}}}),BooleanValueFilter:new d({name:"BooleanValueFilter",isOneOf:!0,fields:{isNull:{type:r},equalTo:{type:r}}}),FloatValueFilter:V(a),IntValueFilter:V(c),StringValueFilter:V(_)},B={GraphQLBoolean:"BooleanValueFilter",GraphQLDID:"AccountValueFilter",GraphQLFloat:"FloatValueFilter",GraphQLInt:"IntValueFilter",GraphQLString:"StringValueFilter"},k=new d({name:"PatchSetOperation",fields:{path:{type:new f(_)},value:{type:F}}}),N=new d({name:"PatchRemoveOperation",fields:{path:{type:new f(_)}}}),Q=new d({name:"PatchDestinationOperation",fields:{from:{type:new f(_)},path:{type:new f(_)}}});export const PatchOperation=new d({name:"PatchOperation",isOneOf:!0,fields:{add:{type:k},set:{type:k},remove:{type:N},replace:{type:k},copy:{type:Q},move:{type:Q}}});let U=new o({name:"OrderByDirection",values:{ASC:{value:"asc"},DESC:{value:"desc"}}});export class SchemaBuilder{_aliases;_aliasToModelID;_definitions;_implemented={};_includedModelIDs;_includeInterfaceDependencies;_includeMutations;_includeRelationDependencies;_includeSubscriptions;_inputObjects={...x,PatchOperation};_mutations={};_nodeModelIDs;_onlyModels;_record;_references={};_relationsTo={};_subscriptions={};_types={OrderByDirection:U};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._aliasToModelID=e.aliases??{},this._aliases={},Object.entries(this._aliasToModelID)))this._aliases[i]=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=G(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:{...D,filter:n,orderBy:{type:toList(this._inputObjects[`${e}-order`])},search:{type:_}},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 m({name:"SearchResultEdge",fields:()=>({cursor:{type:new f(_)},node:{type:new f(e.nodeInterface)},rank:{type:new f(a)}})}),l=new m({name:"SearchResultConnection",fields:()=>({edges:{type:new f(new h(new f(s)))},pageInfo:{type:n}})});t.search={type:new f(l),args:{query:{type:new f(_)},models:{type:new h(new f(_))},first:{type:c},after:{type:_}},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))],d=new Map((a.length>0?await i.resolveList(u,a):[]).map(e=>[e.id,e])),c=[];for(let e of o){let t=d.get(e.documentID);null!=t&&c.push({cursor:String(c.length),node:t,rank:Math.abs(e.rank)})}return{edges:c,pageInfo:{hasNextPage:!1,hasPreviousPage:!1,startCursor:c.length>0?c[0].cursor:null,endCursor:c.length>0?c[c.length-1].cursor:null}}}}}this._includeMutations&&(this._mutations.setModelAccessDefaults={type:e.modelAccessDefaultsObject,args:{modelId:{type:new f(u)},permissionType:{type:new f(_)},accessLevel:{type:new f(_)},allowedDIDs:{type:toList(_)}},resolve:async(e,t,i)=>await i.executeSetModelAccessDefaults(t.modelId,t.permissionType,t.accessLevel,t.allowedDIDs??null)},this._mutations.removeModelAccessDefaults={type:r,args:{modelId:{type:new f(u)},permissionTypes:{type:new f(toList(_))}},resolve:async(e,t,i)=>(await i.executeRemoveModelAccessDefaults(t.modelId,t.permissionTypes),!0)},this._mutations.setDocumentAccessOverride={type:e.documentInterface,args:{documentId:{type:new f(u)},permissionType:{type:new f(_)},accessLevel:{type:new f(_)},allowedDIDs:{type:toList(_)}},resolve:async(e,t,i)=>await i.executeSetDocumentAccessOverride(t.documentId,t.permissionType,t.accessLevel,t.allowedDIDs??null)},this._mutations.removeDocumentAccessOverride={type:r,args:{documentId:{type:new f(u)},permissionTypes:{type:new f(toList(_))}},resolve:async(e,t,i)=>(await i.executeRemoveDocumentAccessOverride(t.documentId,t.permissionTypes),!0)});let n={query:new m({name:"Query",fields:t})};return this._includeMutations&&(n.mutation=new m({name:"Mutation",fields:this._mutations})),this._includeSubscriptions&&(n.subscription=new m({name:"Subscription",fields:()=>{let t={documentChanged:{type:new f(e.documentInterface),args:{id:{type:new f(u)}},resolve:e=>e,subscribe:(e,t,i)=>i.subscribeToDocumentChanged(t.id)},documentRemoved:{type:new f(u),resolve:e=>e,subscribe:(e,t,i)=>i.subscribeToDocumentRemoved()}};for(let[e,i]of Object.entries(this._record)){if(!this._includedModelIDs.has(e))continue;let n=this._aliases[e];for(let s of(t[`new${n}Created`]={type:new f(this._types[e]),resolve:e=>e,subscribe:(t,i,n)=>n.subscribeToDocumentCreated(this.getModelIDs(e))},i.interfaces??[])){let i=getGlobalID(s,e).toString();for(let[e,n]of Object.entries(this._relationsTo[i]??{}))for(let s of n)this._buildRelationSubscriptions(t,i,e,s)}for(let[i,n]of Object.entries(this._relationsTo[e]??{}))for(let s of n)this._includedModelIDs.has(s.model)&&this._buildRelationSubscriptions(t,e,i,s)}return t}})),new y(n)}_getDefinitions(){if(null==this._definitions)throw Error("Definitions must be initialized");return this._definitions}_getReference(e,t){let i=G(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=G(e),s=this._getReferenceSchema(n);if("array"===s.type)return new h(new f(this._getReferenceInput(s.items.$ref,!1,s.title)));if("object"===s.type){if(s.additionalProperties)return T;let e=t?`${n}-partial`:n,r=this._inputObjects[e];if(null!=r)return r;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 f(n)}}let a=this._aliases[n]??l(i+s.title),u=new d({name:t?`Partial${a}Input`:`${a}Input`,fields:o});return this._inputObjects[e]=u,u}return this._buildScalar(n,s,i)}_buildSharedDefinitions(){let i=$(async(i,s)=>{if(i.startsWith("did:"))return i;let l=n(i);if(l instanceof e)return l;if(l instanceof t)return await s.loadDocument(i);throw Error(`Unsupported node ID: ${i}`)},t=>"string"==typeof t?"AccountNode":t instanceof e?"AttachmentNode":this._aliases[t.model]),s=new m({name:"AccountNode",interfaces:[i.nodeInterface],fields:()=>{let e={id:{type:new f(u),description:"Globally unique identifier of the account (DID string)",resolve:e=>e},isViewer:{type:new f(r),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:{...D,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 f(this._buildSetInputObjectType(i,n.uniqueFields))}}:{},resolve:async(e,s,l)=>{let r=q(n.uniqueFields,s.with),o=t.create(i,e,r);return await l.loadDocument(o.toString())}}}}return e}}),l=new m({name:"AttachmentNode",interfaces:[i.nodeInterface],fields:{id:{type:new f(u),resolve:e=>e.toString()},contentLength:{type:new f(c)},mimeType:{type:new f(_)}}}),o=new m({name:"AccessRule",fields:{level:{type:new f(_)},allowedDIDs:{type:new h(new f(_))}}}),a=new m({name:"AccessPermissions",fields:{read:{type:o},write:{type:o}}}),d=new m({name:"ModelAccessDefaults",fields:()=>({ownerDID:{type:new f(_)},modelId:{type:new f(u)},permissions:{type:new f(a)}})}),y={id:{type:new f(u)},model:{type:new f(_)},owner:{type:new f(s)},createdAt:{type:new f(j)},updatedAt:{type:j},accessPermissions:{type:a,resolve:e=>e.data?.accessPermissions??null}},b=new p({name:"DocumentNode",interfaces:[i.nodeInterface],fields:y,resolveType:e=>this._aliases[e.model]}),w={node:i.nodeField,viewer:{type:s,description:"Account issuing the request, if authenticated",resolve:(e,t,i)=>i.getViewer()}};return{...i,accountObject:s,attachmentObject:l,modelAccessDefaultsObject:d,documentInterface:b,documentNodeFields:y,queryFields:w}}_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]??=l(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)},r="interface"===t.behavior,o=r?new p({...s,resolveType:e=>this._aliases[e.model]}):new m(s),{connectionType:a,edgeType:d}=I({nodeType:o});return this._types[e]=o,this._types[`${e}-connection`]=a,this._types[`${e}-edge`]=d,this._buildDocumentDataObject(e,t,n),this._buildDocumentInput(e,t),this._buildObjectFilterInput(e,t.schema,n,!0),this._buildObjectOrderByInput(e,t.schema,n,!0),!r&&this._includeMutations&&("default"===t.behavior?this._mutations[`create${n}`]=O({name:`Create${n}`,inputFields:()=>({data:{type:new f(this._inputObjects[e])}}),outputFields:()=>({...i.queryFields,document:{type:this._types[e]}}),mutateAndGetPayload:async(t,i,n)=>({document:await i.executeCreateMutation(e,t.data,n)})}):"unique"===t.behavior&&(this._mutations[`set${n}`]=O({name:`Set${n}`,inputFields:()=>({data:{type:new f(this._inputObjects[e])}}),outputFields:()=>({...i.queryFields,document:{type:this._types[e]}}),mutateAndGetPayload:async(i,n,s)=>{let l=q(t.uniqueFields,i.data);return{document:await n.executeSetMutation(e,l,i.data,s)}}})),this._mutations[`update${n}`]=O({name:`Update${n}`,inputFields:()=>({id:{type:new f(u)},patch:{type:new f(toList(PatchOperation))},from:{type:this._inputObjects[`${e}-update`]}}),outputFields:()=>({...i.queryFields,document:{type:this._types[e]}}),mutateAndGetPayload:async(e,t,i)=>({document:await t.executeUpdateMutation(e,i)})}),this._mutations[`remove${n}`]=O({name:`Remove${n}`,inputFields:()=>({id:{type:new f(u)}}),outputFields:()=>({...i.queryFields,id:{type:new f(u)}}),mutateAndGetPayload:async(e,t,i)=>(await t.executeRemoveMutation(e.id,i),{id:e.id})})),o}_buildDocumentFields(t,i,n){let s=this._buildDocumentDataObject(t,i,n),l=this._getDefinitions(),r={...l.documentNodeFields,data:{type:new f(s)}};for(let[n,o]of Object.entries(s.getFields())){let s=i.fieldsMeta[n];if(null!=s)switch(s.type){case"account":C(o.type)?r[`${n}Accounts`]={type:new f(toOuputList(l.accountObject)),resolve:e=>e.data?.[n]??[]}:r[`${n}Account`]={type:l.accountObject,resolve:e=>e.data?.[n]??null};break;case"attachment":C(o.type)?r[`${n}Attachments`]={type:new f(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)),C(o.type)?r[`${n}Documents`]={type:new f(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 f(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 p(r):new m(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 f(r):r};let o=G(l);null==this._getReferenceSchema(o).const&&(n[e]={type:this._getReferenceInput(l,!0)})}let s=this._aliases[e];this._inputObjects[e]=new d({name:`${s}Input`,fields:i}),this._inputObjects[`${e}-update`]=new d({name:`Partial${s}Input`,fields:n})}_buildReferenceFilterInput(e,t=""){let i=G(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]??l(t+n.title);return s=e,new d({name:`${e}Filter`,isOneOf:!0,fields:{isNull:{type:r}}})}let o=this._buildScalar(i,n,s),a=B[o.name];if(null!=a)return this._inputObjects[a];let u=b(o)?new d({name:`${o.name}ValueFilter`,isOneOf:!0,fields:{isNull:{type:r},equalTo:{type:o},notEqualTo:{type:o},in:{type:toList(o)},notIn:{type:toList(o)}}}):V(o);return null==this._inputObjects[u.name]&&(this._inputObjects[u.name]=u),this._inputObjects[u.name]}_buildReferenceOrderByInput(e,t=""){let i=G(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 U}}_buildObjectFilterInput(e,t,i="",n=!1){let s=`${e}-filter`,r=this._inputObjects[s];if(null!=r)return r;let o=this._aliases[e]??l(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 d({name:`${o}ObjectFilter`,fields:a}),c=new d({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`,r=this._inputObjects[s];if(null!=r)return r;let o=this._aliases[e]??l(i+(t.title??"")),a=n?{_docOwner:{type:U},_createdAt:{type:U}}:{};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 d({name:`${o}OrderBy`,isOneOf:!0,fields:a});return this._inputObjects[s]=u,u}_buildSetInputObjectType(e,t,i){let n=i?l(i):"",s=`${e}-with-${n}`,r=this._inputObjects[s];if(null!=r)return r;let o=this._record[e],a=this._aliases[e];return this._inputObjects[s]=new d({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 f(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?T: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]=r;break;case"integer":this._types[e]=c;break;case"number":this._types[e]=a;break;case"string":this._types[e]=this._buildString(t,i)}return this._types[e]}_buildArray(e,t=""){let i=e.items.$ref;return new h(new f(this._getReference(i,l(t+e.title))))}_buildObject(e,t,i=""){let n=l(i+t.title),s=this._buildObjectFields(e,t,n);return new m({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 f(o):o}}return s}_buildRelationFields(e,t,i){if(i.isList)return;let n=i.model,s=`${l(t)}Of${this._aliases[n]}`;e[`in${s}`]={type:new f(this._types[`${n}-connection`]),args:{...D,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=l(i);e[`edge${this._aliases[n.model]}AddedAs${s}To${this._aliases[t]}`]={type:new f(this._types[`${n.model}-edge`]),args:{id:{type:new f(u)}},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 f(u),args:{id:{type:new f(u)}},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?_:null!=e.enum?this._buildEnumString(e,t):null!=e.format?this._buildFormatString(e):this._buildCustomString(e)}_buildCustomString(e){return null==e.title?_:E[e.title.toLowerCase()]??_}_buildEnumString(e,t=""){let i=l(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 o({name:i,values:t})}return this._types[n]}_buildFormatString(e){let t=P[e.format];if(null==t)throw Error(`Unsupported string format: ${e.format}`);return t}}export function createSchema(e){return new SchemaBuilder(e).build()}