@kubun/graphql 0.16.0 → 0.17.1

package/lib/context.d.ts

@@ -3,7 +3,7 @@ import type { AggregateHaving, AggregateSpec, AggregateValues, DocumentData, Doc
 import type { SearchDocumentResult, SearchDocumentsParams, StoredAccessDefaultRow, ViewerReadAccess } from '@kubun/store-graph';
 import type { Tracer } from '@sozai/otel';
 import type { GraphQLResolveInfo } from 'graphql';
-import type { Connection, Edge } from 'graphql-relay';
+import type { Connection, Edge } from './relay.js';
 import type { AllConnectionArguments, ModelAccessDefaults, UpdateMutationInput } from './types.js';
 /**
  * Event data for document save notifications used by subscriptions.
@@ -90,7 +90,7 @@ export type AggregateScope = {
 };
 /**
  * Connection value returned by {@link QueryContext.resolveConnection}. Extends
- * the graphql-relay connection (edges/pageInfo are untouched) with the query
+ * the Relay connection (edges/pageInfo are untouched) with the query
  * scope so the `aggregates` field can resolve consistently with the page.
  */
 export type ScopedConnection = Connection<DocumentNode> & {

package/lib/relay.d.ts

@@ -0,0 +1,93 @@
+import { type GraphQLFieldConfig, type GraphQLFieldConfigArgumentMap, type GraphQLFieldExtensions, type GraphQLFieldResolver, type GraphQLInputFieldConfig, GraphQLInterfaceType, type GraphQLNamedOutputType, GraphQLNonNull, GraphQLObjectType, type GraphQLResolveInfo, type GraphQLTypeResolver, type ThunkObjMap } from 'graphql';
+/**
+ * Internal reimplementation of the small slice of `graphql-relay` this package
+ * uses (connection args/types, `Node` interface, and Relay-style mutations).
+ * The emitted GraphQL types are byte-identical to `graphql-relay@0.10`, which
+ * the schema snapshot tests verify.
+ */
+/** A type alias for cursors in this implementation. */
+export type ConnectionCursor = string;
+/** A type describing the arguments a connection field receives in GraphQL. */
+export type ConnectionArguments = {
+    before?: ConnectionCursor | null;
+    after?: ConnectionCursor | null;
+    first?: number | null;
+    last?: number | null;
+};
+/** A type designed to be exposed as a `Connection` over GraphQL. */
+export type Connection<T> = {
+    edges: Array<Edge<T>>;
+    pageInfo: PageInfo;
+};
+/** A type designed to be exposed as an `Edge` over GraphQL. */
+export type Edge<T> = {
+    node: T;
+    cursor: ConnectionCursor;
+};
+/** A type designed to be exposed as `PageInfo` over GraphQL. */
+export type PageInfo = {
+    startCursor: ConnectionCursor | null;
+    endCursor: ConnectionCursor | null;
+    hasPreviousPage: boolean;
+    hasNextPage: boolean;
+};
+/**
+ * Args to include on a field whose return type is a connection type with
+ * forward pagination.
+ */
+export declare const forwardConnectionArgs: GraphQLFieldConfigArgumentMap;
+/**
+ * Args to include on a field whose return type is a connection type with
+ * backward pagination.
+ */
+export declare const backwardConnectionArgs: GraphQLFieldConfigArgumentMap;
+/**
+ * Args to include on a field whose return type is a connection type with
+ * bidirectional pagination.
+ */
+export declare const connectionArgs: GraphQLFieldConfigArgumentMap;
+export type ConnectionConfig = {
+    name?: string;
+    nodeType: GraphQLNamedOutputType | GraphQLNonNull<GraphQLNamedOutputType>;
+    resolveNode?: GraphQLFieldResolver<any, any>;
+    resolveCursor?: GraphQLFieldResolver<any, any>;
+    edgeFields?: ThunkObjMap<GraphQLFieldConfig<any, any>>;
+    connectionFields?: ThunkObjMap<GraphQLFieldConfig<any, any>>;
+};
+export type GraphQLConnectionDefinitions = {
+    edgeType: GraphQLObjectType;
+    connectionType: GraphQLObjectType;
+};
+/**
+ * Returns a GraphQLObjectType for a connection with the given name, and whose
+ * nodes are of the specified type.
+ */
+export declare function connectionDefinitions(config: ConnectionConfig): GraphQLConnectionDefinitions;
+export type GraphQLNodeDefinitions<TContext> = {
+    nodeInterface: GraphQLInterfaceType;
+    nodeField: GraphQLFieldConfig<unknown, TContext>;
+    nodesField: GraphQLFieldConfig<unknown, TContext>;
+};
+/**
+ * Given a function to map from an ID to an underlying object, and a function to
+ * map from an underlying object to its concrete GraphQLObjectType, constructs a
+ * `Node` interface plus `node`/`nodes` root field configs.
+ */
+export declare function nodeDefinitions<TContext>(fetchById: (id: string, context: TContext, info: GraphQLResolveInfo) => unknown, typeResolver?: GraphQLTypeResolver<unknown, TContext>): GraphQLNodeDefinitions<TContext>;
+type MutationFn<TInput, TOutput, TContext> = (object: TInput, ctx: TContext, info: GraphQLResolveInfo) => TOutput;
+export type MutationConfig<TInput = any, TOutput = unknown, TContext = unknown> = {
+    name: string;
+    description?: string;
+    deprecationReason?: string;
+    extensions?: GraphQLFieldExtensions<unknown, unknown>;
+    inputFields: ThunkObjMap<GraphQLInputFieldConfig>;
+    outputFields: ThunkObjMap<GraphQLFieldConfig<TOutput, TContext>>;
+    mutateAndGetPayload: MutationFn<TInput, Promise<TOutput> | TOutput, TContext>;
+};
+/**
+ * Returns a GraphQLFieldConfig for the mutation described by the provided
+ * config, wiring the Relay `clientMutationId` round-trip through a generated
+ * `${name}Input`/`${name}Payload` pair.
+ */
+export declare function mutationWithClientMutationId<TInput = any, TOutput = unknown, TContext = unknown>(config: MutationConfig<TInput, TOutput, TContext>): GraphQLFieldConfig<unknown, TContext>;
+export {};

package/lib/relay.js

@@ -0,0 +1,197 @@
+import { GraphQLBoolean, GraphQLID, GraphQLInputObjectType, GraphQLInt, GraphQLInterfaceType, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLString, getNamedType, resolveObjMapThunk } from 'graphql';
+/**
+ * Args to include on a field whose return type is a connection type with
+ * forward pagination.
+ */ export const forwardConnectionArgs = Object.freeze({
+    after: {
+        type: GraphQLString,
+        description: 'Returns the items in the list that come after the specified cursor.'
+    },
+    first: {
+        type: GraphQLInt,
+        description: 'Returns the first n items from the list.'
+    }
+});
+/**
+ * Args to include on a field whose return type is a connection type with
+ * backward pagination.
+ */ export const backwardConnectionArgs = Object.freeze({
+    before: {
+        type: GraphQLString,
+        description: 'Returns the items in the list that come before the specified cursor.'
+    },
+    last: {
+        type: GraphQLInt,
+        description: 'Returns the last n items from the list.'
+    }
+});
+/**
+ * Args to include on a field whose return type is a connection type with
+ * bidirectional pagination.
+ */ export const connectionArgs = {
+    ...forwardConnectionArgs,
+    ...backwardConnectionArgs
+};
+/** The common page info type shared by every connection. */ const pageInfoType = new GraphQLObjectType({
+    name: 'PageInfo',
+    description: 'Information about pagination in a connection.',
+    fields: ()=>({
+            hasNextPage: {
+                type: new GraphQLNonNull(GraphQLBoolean),
+                description: 'When paginating forwards, are there more items?'
+            },
+            hasPreviousPage: {
+                type: new GraphQLNonNull(GraphQLBoolean),
+                description: 'When paginating backwards, are there more items?'
+            },
+            startCursor: {
+                type: GraphQLString,
+                description: 'When paginating backwards, the cursor to continue.'
+            },
+            endCursor: {
+                type: GraphQLString,
+                description: 'When paginating forwards, the cursor to continue.'
+            }
+        })
+});
+/**
+ * Returns a GraphQLObjectType for a connection with the given name, and whose
+ * nodes are of the specified type.
+ */ export function connectionDefinitions(config) {
+    const { nodeType } = config;
+    const name = config.name ?? getNamedType(nodeType).name;
+    const edgeType = new GraphQLObjectType({
+        name: `${name}Edge`,
+        description: 'An edge in a connection.',
+        fields: ()=>({
+                node: {
+                    type: nodeType,
+                    resolve: config.resolveNode,
+                    description: 'The item at the end of the edge'
+                },
+                cursor: {
+                    type: new GraphQLNonNull(GraphQLString),
+                    resolve: config.resolveCursor,
+                    description: 'A cursor for use in pagination'
+                },
+                ...resolveObjMapThunk(config.edgeFields ?? {})
+            })
+    });
+    const connectionType = new GraphQLObjectType({
+        name: `${name}Connection`,
+        description: 'A connection to a list of items.',
+        fields: ()=>({
+                pageInfo: {
+                    type: new GraphQLNonNull(pageInfoType),
+                    description: 'Information to aid in pagination.'
+                },
+                edges: {
+                    type: new GraphQLList(edgeType),
+                    description: 'A list of edges.'
+                },
+                ...resolveObjMapThunk(config.connectionFields ?? {})
+            })
+    });
+    return {
+        edgeType,
+        connectionType
+    };
+}
+/**
+ * Given a function to map from an ID to an underlying object, and a function to
+ * map from an underlying object to its concrete GraphQLObjectType, constructs a
+ * `Node` interface plus `node`/`nodes` root field configs.
+ */ export function nodeDefinitions(fetchById, typeResolver) {
+    const nodeInterface = new GraphQLInterfaceType({
+        name: 'Node',
+        description: 'An object with an ID',
+        fields: ()=>({
+                id: {
+                    type: new GraphQLNonNull(GraphQLID),
+                    description: 'The id of the object.'
+                }
+            }),
+        resolveType: typeResolver
+    });
+    const nodeField = {
+        description: 'Fetches an object given its ID',
+        type: nodeInterface,
+        args: {
+            id: {
+                type: new GraphQLNonNull(GraphQLID),
+                description: 'The ID of an object'
+            }
+        },
+        resolve: (_obj, { id }, context, info)=>fetchById(id, context, info)
+    };
+    const nodesField = {
+        description: 'Fetches objects given their IDs',
+        type: new GraphQLNonNull(new GraphQLList(nodeInterface)),
+        args: {
+            ids: {
+                type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(GraphQLID))),
+                description: 'The IDs of objects'
+            }
+        },
+        resolve: (_obj, { ids }, context, info)=>ids.map((id)=>fetchById(id, context, info))
+    };
+    return {
+        nodeInterface,
+        nodeField,
+        nodesField
+    };
+}
+function isPromiseLike(value) {
+    return typeof value?.then === 'function';
+}
+/**
+ * Returns a GraphQLFieldConfig for the mutation described by the provided
+ * config, wiring the Relay `clientMutationId` round-trip through a generated
+ * `${name}Input`/`${name}Payload` pair.
+ */ export function mutationWithClientMutationId(config) {
+    const { name, inputFields, outputFields, mutateAndGetPayload } = config;
+    const outputType = new GraphQLObjectType({
+        name: `${name}Payload`,
+        fields: ()=>({
+                ...resolveObjMapThunk(outputFields),
+                clientMutationId: {
+                    type: GraphQLString
+                }
+            })
+    });
+    const inputType = new GraphQLInputObjectType({
+        name: `${name}Input`,
+        fields: ()=>({
+                ...resolveObjMapThunk(inputFields),
+                clientMutationId: {
+                    type: GraphQLString
+                }
+            })
+    });
+    return {
+        type: outputType,
+        description: config.description,
+        deprecationReason: config.deprecationReason,
+        extensions: config.extensions,
+        args: {
+            input: {
+                type: new GraphQLNonNull(inputType)
+            }
+        },
+        resolve: (_source, { input }, context, info)=>{
+            const { clientMutationId } = input;
+            const injectClientMutationId = (data)=>{
+                if (typeof data === 'object' && data !== null) {
+                    ;
+                    data.clientMutationId = clientMutationId;
+                }
+                return data;
+            };
+            const payload = mutateAndGetPayload(input, context, info);
+            if (isPromiseLike(payload)) {
+                return payload.then((value)=>injectClientMutationId(value));
+            }
+            return injectClientMutationId(payload);
+        }
+    };
+}

package/lib/schema.d.ts

@@ -1,11 +1,11 @@
 import { AttachmentID, DocumentModelID } from '@kubun/id';
 import type { AggregateHaving, AggregateSpec, ArrayModel, DocumentData, DocumentModel, DocumentModelSchema, DocumentModelsRecord, DocumentNode, GroupedAggregateOrderTerm, ObjectModel, OrderByDirection as OrderByDirectionValue, ReferencesRecordModel, ScalarModel, StringCustomModel, StringEnumModel, StringFormatModel, StringModel, TypeModel } from '@kubun/protocol';
-import { type FieldNode, GraphQLEnumType, type GraphQLFieldConfig, type GraphQLFieldConfigMap, type GraphQLFieldResolver, GraphQLInputObjectType, type GraphQLInputType, GraphQLInterfaceType, GraphQLList, GraphQLNonNull, GraphQLObjectType, type GraphQLOutputType, type GraphQLResolveInfo, type GraphQLScalarType, GraphQLSchema, type SelectionNode } from 'graphql';
+import { type FieldNode, GraphQLEnumType, type GraphQLFieldConfig, type GraphQLFieldConfigMap, type GraphQLFieldResolver, GraphQLInputObjectType, type GraphQLInputType, GraphQLInterfaceType, GraphQLList, GraphQLNonNull, type GraphQLNullableInputType, type GraphQLNullableOutputType, GraphQLObjectType, type GraphQLOutputType, type GraphQLResolveInfo, type GraphQLScalarType, GraphQLSchema, type SelectionNode } from 'graphql';
 import type { Context } from './context.js';
 export declare function toDocumentModelID(id: DocumentModelID | string): DocumentModelID;
 export declare function getGlobalID(id: DocumentModelID | string, globalID: DocumentModelID | string): DocumentModelID;
-export declare function toList(type: GraphQLInputType): GraphQLList<GraphQLNonNull<GraphQLInputType>>;
-export declare function toOuputList(type: GraphQLOutputType): GraphQLList<GraphQLNonNull<GraphQLOutputType>>;
+export declare function toList(type: GraphQLNullableInputType): GraphQLList<GraphQLNonNull<GraphQLNullableInputType>>;
+export declare function toOuputList(type: GraphQLNullableOutputType): GraphQLList<GraphQLNonNull<GraphQLNullableOutputType>>;
 export declare const PatchOperation: GraphQLInputObjectType;
 export type GraphQLNodeDefinitions = {
     nodeInterface: GraphQLInterfaceType;
@@ -99,16 +99,18 @@ export declare class SchemaBuilder {
         resolve: (localID: string, ctx: Context) => Promise<unknown> | unknown;
     }>;
     _subscriptions: GraphQLFieldConfigMap<unknown, Context>;
-    _types: Record<string, GraphQLOutputType>;
+    _types: Record<string, GraphQLNullableOutputType>;
     constructor(params: SchemaBuilderParams);
     _resolveModelIdentifier(identifier: string): string;
     _resolveModelIDsToInclude(): Set<string>;
     getModelIDs(id: string | null): Array<string>;
     build(): GraphQLSchema;
     _getDefinitions(): SharedDefinitions;
-    _getReference(path: string, parentName?: string): GraphQLOutputType;
+    _getReference(path: string, parentName?: string): GraphQLNullableOutputType;
     _getReferenceSchema(id: string): TypeModel;
-    _getReferenceInput(path: string, isPartial: boolean, parentName?: string): GraphQLInputType;
+    _getInputObject(key: string): GraphQLInputObjectType;
+    _getType(key: string): GraphQLOutputType;
+    _getReferenceInput(path: string, isPartial: boolean, parentName?: string): GraphQLNullableInputType;
     _buildSharedDefinitions(): SharedDefinitions;
     _buildDocument(id: string): GraphQLObjectType<DocumentNode, Context> | GraphQLInterfaceType;
     /**
@@ -189,9 +191,9 @@ export declare class SchemaBuilder {
     _buildObjectFilterInput(id: string, schema: DocumentModelSchema | ObjectModel, parentName?: string, isDocument?: boolean): GraphQLInputObjectType;
     _buildObjectOrderByInput(id: string, schema: DocumentModelSchema | ObjectModel, parentName?: string, isDocument?: boolean): GraphQLInputObjectType;
     _buildSetInputObjectType(id: string, withFields: Array<string>, relationField?: string): GraphQLInputObjectType;
-    _buildReference(id: string, schema: TypeModel, parentName?: string): GraphQLOutputType;
+    _buildReference(id: string, schema: TypeModel, parentName?: string): GraphQLNullableOutputType;
     _buildScalar(id: string, schema: ScalarModel, parentName?: string): GraphQLScalarType;
-    _buildArray(schema: ArrayModel, parentName?: string): GraphQLList<GraphQLNonNull<GraphQLOutputType>>;
+    _buildArray(schema: ArrayModel, parentName?: string): GraphQLList<GraphQLNonNull<GraphQLNullableOutputType>>;
     _buildObject(id: string, schema: ObjectModel, parentName?: string): GraphQLObjectType;
     _buildObjectFields(id: string, schema: DocumentModelSchema | ObjectModel, parentName?: string): GraphQLFieldConfigMap<Record<string, unknown>, Context>;
     _buildNestedAttachmentField(key: string, fieldRef: string): GraphQLFieldConfig<Record<string, unknown>, Context> | null;

package/lib/schema.js

@@ -2,9 +2,9 @@ import { AttachmentID, DocumentID, DocumentModelID, decodeID, PluginNodeID } fro
 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, GraphQLCredentialEntryID, GraphQLDocID } from './identifiers.js';
+import { connectionArgs, connectionDefinitions, mutationWithClientMutationId, nodeDefinitions } from './relay.js';
 import { GraphQLURL } from './scalars.js';
 import { decodeSearchCursor, encodeSearchCursor } from './search-cursor.js';
 import { getUniqueDocValue, validateAccessIdentifiers } from './utils.js';
@@ -434,7 +434,11 @@ export class SchemaBuilder {
             // 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 relationRef = model.schema.properties[fieldName]?.$ref;
+                    if (relationRef == null) {
+                        throw new Error(`Field ${fieldName} not found on model ${modelIDstring}`);
+                    }
+                    const relationRefID = getReferenceID(relationRef);
                     const isList = this._getReferenceSchema(relationRefID).type === 'array';
                     const relationID = getGlobalID(meta.model, modelID).toString();
                     this._relationsTo[relationID] ??= {};
@@ -537,7 +541,7 @@ export class SchemaBuilder {
             this._buildDocument(id);
             const name = this._aliases[id];
             const filterArg = {
-                type: this._inputObjects[`${id}-filter`]
+                type: this._getInputObject(`${id}-filter`)
             };
             queryFields[`all${name}`] = {
                 type: this._types[`${id}-connection`],
@@ -545,7 +549,7 @@ export class SchemaBuilder {
                     ...connectionArgs,
                     filter: filterArg,
                     orderBy: {
-                        type: toList(this._inputObjects[`${id}-order`])
+                        type: toList(this._getInputObject(`${id}-order`))
                     },
                     search: {
                         type: GraphQLString
@@ -557,13 +561,17 @@ export class SchemaBuilder {
             };
         }
         // Add top-level search query across all models
-        // Get the PageInfo type from an existing connection (shared by graphql-relay)
+        // Get the PageInfo type from an existing connection (shared across all connections)
         const firstModelID = [
             ...this._includedModelIDs
         ][0];
         if (firstModelID != null) {
             const someConnectionType = this._types[`${firstModelID}-connection`];
-            const pageInfoType = someConnectionType.getFields().pageInfo.type;
+            const pageInfoField = someConnectionType.getFields().pageInfo;
+            if (pageInfoField == null) {
+                throw new Error('Connection type is missing the pageInfo field');
+            }
+            const pageInfoType = pageInfoField.type;
             const searchResultEdge = new GraphQLObjectType({
                 name: 'SearchResultEdge',
                 fields: ()=>({
@@ -641,6 +649,9 @@ export class SchemaBuilder {
                     const edges = [];
                     for(let j = 0; j < page.length; j++){
                         const r = page[j];
+                        if (r == null) {
+                            continue;
+                        }
                         const node = docMap.get(r.documentID);
                         if (node != null) {
                             // Cursor = hits consumed through this position, so the next page
@@ -658,7 +669,7 @@ export class SchemaBuilder {
                         pageInfo: {
                             hasNextPage,
                             hasPreviousPage: offset > 0,
-                            startCursor: edges.length > 0 ? edges[0].cursor : null,
+                            startCursor: edges.length > 0 ? edges[0]?.cursor ?? null : null,
                             endCursor: page.length > 0 ? encodeSearchCursor(endOffset) : null
                         }
                     };
@@ -1074,6 +1085,20 @@ export class SchemaBuilder {
         }
         return schema;
     }
+    _getInputObject(key) {
+        const input = this._inputObjects[key];
+        if (input == null) {
+            throw new Error(`Could not find input object: ${key}`);
+        }
+        return input;
+    }
+    _getType(key) {
+        const type = this._types[key];
+        if (type == null) {
+            throw new Error(`Could not find type: ${key}`);
+        }
+        return type;
+    }
     _getReferenceInput(path, isPartial, parentName = '') {
         const id = getReferenceID(path);
         const schema = this._getReferenceSchema(id);
@@ -1176,10 +1201,10 @@ export class SchemaBuilder {
                                     args: {
                                         ...connectionArgs,
                                         filter: {
-                                            type: this._inputObjects[`${id}-filter`]
+                                            type: this._getInputObject(`${id}-filter`)
                                         },
                                         orderBy: {
-                                            type: toList(this._inputObjects[`${id}-order`])
+                                            type: toList(this._getInputObject(`${id}-order`))
                                         }
                                     },
                                     resolve: async (owner, args, ctx)=>{
@@ -1341,13 +1366,13 @@ export class SchemaBuilder {
                         type: new GraphQLNonNull(toOuputList(groupedAggregateType)),
                         args: {
                             groupBy: {
-                                type: new GraphQLNonNull(toList(this._inputObjects[`${id}-group-by`]))
+                                type: new GraphQLNonNull(toList(this._getInputObject(`${id}-group-by`)))
                             },
                             having: {
-                                type: this._inputObjects[`${id}-having`]
+                                type: this._getInputObject(`${id}-having`)
                             },
                             orderBy: {
-                                type: toList(this._inputObjects[`${id}-group-order`])
+                                type: toList(this._getInputObject(`${id}-group-order`))
                             },
                             limit: {
                                 type: GraphQLInt
@@ -1396,7 +1421,7 @@ export class SchemaBuilder {
                     name: `Create${name}`,
                     inputFields: ()=>({
                             data: {
-                                type: new GraphQLNonNull(this._inputObjects[id])
+                                type: new GraphQLNonNull(this._getInputObject(id))
                             },
                             transactionID: {
                                 type: GraphQLID
@@ -1405,7 +1430,7 @@ export class SchemaBuilder {
                     outputFields: ()=>({
                             ...definitions.queryFields,
                             document: {
-                                type: this._types[id]
+                                type: this._getType(id)
                             }
                         }),
                     mutateAndGetPayload: async (input, ctx, info)=>{
@@ -1425,7 +1450,7 @@ export class SchemaBuilder {
                     name: `Set${name}`,
                     inputFields: ()=>({
                             data: {
-                                type: new GraphQLNonNull(this._inputObjects[id])
+                                type: new GraphQLNonNull(this._getInputObject(id))
                             },
                             transactionID: {
                                 type: GraphQLID
@@ -1434,7 +1459,7 @@ export class SchemaBuilder {
                     outputFields: ()=>({
                             ...definitions.queryFields,
                             document: {
-                                type: this._types[id]
+                                type: this._getType(id)
                             }
                         }),
                     mutateAndGetPayload: async (input, ctx, info)=>{
@@ -1462,7 +1487,7 @@ export class SchemaBuilder {
                             type: new GraphQLNonNull(toList(PatchOperation))
                         },
                         from: {
-                            type: this._inputObjects[`${id}-update`]
+                            type: this._getInputObject(`${id}-update`)
                         },
                         transactionID: {
                             type: GraphQLID
@@ -1471,7 +1496,7 @@ export class SchemaBuilder {
                 outputFields: ()=>({
                         ...definitions.queryFields,
                         document: {
-                            type: this._types[id]
+                            type: this._getType(id)
                         }
                     }),
                 mutateAndGetPayload: async (input, ctx, info)=>{
@@ -1737,14 +1762,14 @@ export class SchemaBuilder {
         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`];
+            return this._getInputObject(`${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
+                type: this._getInputObject('IntValueFilter')
             }
         };
         if (sumType != null && avgType != null) {
@@ -1755,7 +1780,7 @@ export class SchemaBuilder {
                     type: valueFilterFor(field.type)
                 };
                 havingAvgFields[key] = {
-                    type: this._inputObjects.FloatValueFilter
+                    type: this._getInputObject('FloatValueFilter')
                 };
             }
             const havingSum = new GraphQLInputObjectType({
@@ -2281,7 +2306,7 @@ export class SchemaBuilder {
         const scalar = this._buildScalar(id, schema, refParentName);
         const knownFilter = VALUE_FILTER_INPUT_TYPES[scalar.name];
         if (knownFilter != null) {
-            return this._inputObjects[knownFilter];
+            return this._getInputObject(knownFilter);
         }
         const filter = isEnumType(scalar) ? createEnumValueFilterInput(scalar) : createScalarValueFilterInput(scalar, {
             stringBacked: true
@@ -2289,7 +2314,7 @@ export class SchemaBuilder {
         if (this._inputObjects[filter.name] == null) {
             this._inputObjects[filter.name] = filter;
         }
-        return this._inputObjects[filter.name];
+        return this._getInputObject(filter.name);
     }
     _buildReferenceOrderByInput(path, parentName = '') {
         const id = getReferenceID(path);
@@ -2312,7 +2337,7 @@ export class SchemaBuilder {
         const name = this._aliases[id] ?? pascalCase(parentName + (schema.title ?? ''));
         const fields = isDocument ? {
             _owner: {
-                type: this._inputObjects.AccountValueFilter
+                type: this._getInputObject('AccountValueFilter')
             }
         } : {};
         for (const [key, value] of Object.entries(schema.properties)){
@@ -2335,13 +2360,13 @@ export class SchemaBuilder {
                         type: objectInput
                     },
                     and: {
-                        type: toList(this._inputObjects[inputID])
+                        type: toList(this._getInputObject(inputID))
                     },
                     or: {
-                        type: toList(this._inputObjects[inputID])
+                        type: toList(this._getInputObject(inputID))
                     },
                     not: {
-                        type: this._inputObjects[inputID]
+                        type: this._getInputObject(inputID)
                     }
                 })
         });
@@ -2387,6 +2412,9 @@ export class SchemaBuilder {
             return existing;
         }
         const model = this._record[id];
+        if (model == null) {
+            throw new Error(`Model ${id} not found`);
+        }
         const name = this._aliases[id];
         this._inputObjects[inputID] = new GraphQLInputObjectType({
             name: `With${relationFieldName}${name}Input`,
@@ -2504,10 +2532,10 @@ export class SchemaBuilder {
             args: {
                 ...connectionArgs,
                 filter: {
-                    type: this._inputObjects[`${relationID}-filter`]
+                    type: this._getInputObject(`${relationID}-filter`)
                 },
                 orderBy: {
-                    type: toList(this._inputObjects[`${relationID}-order`])
+                    type: toList(this._getInputObject(`${relationID}-order`))
                 }
             },
             resolve: (doc, args, ctx)=>{

package/lib/types.d.ts

@@ -1,5 +1,5 @@
 import type { DocumentData, DocumentFilter, DocumentOrderBy } from '@kubun/protocol';
-import type { ConnectionArguments } from 'graphql-relay';
+import type { ConnectionArguments } from './relay.js';
 export type PatchAddOperation = {
     op: 'add';
     path: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubun/graphql",
-  "version": "0.16.0",
+  "version": "0.17.1",
   "keywords": [],
   "license": "see LICENSE.md",
   "sideEffects": false,
@@ -15,27 +15,26 @@
     "LICENSE.md"
   ],
   "dependencies": {
-    "@kubun/hlc": "^0.16.0",
-    "@kubun/id": "^0.16.0",
-    "@kubun/logger": "^0.16.0",
-    "@kubun/protocol": "^0.16.0",
+    "@kubun/hlc": "^0.17.0",
+    "@kubun/id": "^0.17.0",
+    "@kubun/logger": "^0.17.0",
+    "@kubun/protocol": "^0.17.0",
     "@sozai/async": "^0.2.1",
     "@sozai/codec": "^0.4.0",
     "@sozai/event": "^0.1.3",
     "@sozai/otel": "^0.3.2",
     "change-case": "^5.4.4",
-    "graphql": "^16.14.2",
-    "graphql-relay": "^0.10.2",
+    "graphql": "^17.0.2",
     "graphql-scalars": "^2.0.0",
     "multiformats": "^14.0.5"
   },
   "devDependencies": {
     "@kokuin/capability": "^0.3.0",
     "@kokuin/token": "^0.5.0",
-    "@kubun/db": "^0.16.0",
-    "@kubun/db-better-sqlite": "^0.16.0",
-    "@kubun/scalars": "^0.16.0",
-    "@kubun/store-graph": "^0.16.0",
+    "@kubun/db": "^0.17.0",
+    "@kubun/db-better-sqlite": "^0.17.0",
+    "@kubun/scalars": "^0.17.0",
+    "@kubun/store-graph": "^0.17.0",
     "@kubun/test-utils": "^0.0.0"
   },
   "publishConfig": {
@@ -44,8 +43,8 @@
   "scripts": {
     "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
     "build:clean": "del lib",
-    "build:js": "swc src -d ./lib --config-file ../../node_modules/@kigu/dev/swc.json --strip-leading-paths",
-    "build:types": "tsc --emitDeclarationOnly --skipLibCheck",
+    "build:js": "del 'lib/**/*.js' && swc src -d ./lib --config-file ../../node_modules/@kigu/dev/swc.json --strip-leading-paths",
+    "build:types": "del 'lib/**/*.d.ts' 'lib/**/*.d.ts.map' && tsc --emitDeclarationOnly --skipLibCheck",
     "build:types:ci": "tsc --emitDeclarationOnly --declarationMap false",
     "test": "pnpm run test:types && pnpm run test:unit",
     "test:types": "tsc --noEmit -p tsconfig.test.json",