@kubun/graphql 0.12.0 → 0.13.1

package/lib/identifiers.d.ts

@@ -1,3 +1,4 @@
 import { GraphQLScalarType } from 'graphql';
 export declare const GraphQLAttachmentID: GraphQLScalarType<string, string>;
+export declare const GraphQLCredentialEntryID: GraphQLScalarType<string, string>;
 export declare const GraphQLDocID: GraphQLScalarType<string, string>;

package/lib/identifiers.js

@@ -1,4 +1,4 @@
-import { AttachmentID, DocumentID } from '@kubun/id';
+import { AttachmentID, CredentialEntryID, DocumentID } from '@kubun/id';
 import { GraphQLError, GraphQLScalarType, Kind } from 'graphql';
 function validateAttachmentID(input) {
     if (typeof input !== 'string') {
@@ -20,6 +20,28 @@ export const GraphQLAttachmentID = new GraphQLScalarType({
         return validateAttachmentID(ast.value);
     }
 });
+function validateCredentialEntryID(input) {
+    if (typeof input !== 'string') {
+        throw new GraphQLError(`Invalid CredentialEntryID input: ${input}`);
+    }
+    // The whole check. Every Kubun id matches the scalar's pattern, so a document
+    // id or a credential KEY id would otherwise reach a resolver that expects an
+    // entry and miss with a message about absence rather than about type.
+    CredentialEntryID.fromString(input);
+    return input;
+}
+export const GraphQLCredentialEntryID = new GraphQLScalarType({
+    name: 'CredentialEntryID',
+    description: 'A Kubun Credential Entry identifier',
+    serialize: validateCredentialEntryID,
+    parseValue: validateCredentialEntryID,
+    parseLiteral (ast) {
+        if (ast.kind !== Kind.STRING) {
+            throw new GraphQLError(`Can only validate strings as CredentialEntryID but got a: ${ast.kind}`);
+        }
+        return validateCredentialEntryID(ast.value);
+    }
+});
 function validateDocID(input) {
     if (typeof input !== 'string') {
         throw new GraphQLError(`Invalid DocumentID input: ${input}`);

package/lib/index.d.ts

@@ -1,6 +1,6 @@
 export type { AccessWarning, AggregateScope, ComplexityStats, Context, CreateMutationParams, DocumentEventEmitter, DocumentSavedEvent, MutationContext, PluginContextMap, QueryContext, ReadContextDB, ReadContextParams, ReadOnlyContext, RemoveMutationParams, ScopedConnection, SetDocumentAccessOverrideParams, SetModelAccessDefaultsParams, SetMutationParams, SubscriptionContext, UpdateMutationParams, } from './context.js';
 export { createReadContext } from './context.js';
-export { GraphQLAttachmentID, GraphQLDocID } from './identifiers.js';
+export { GraphQLAttachmentID, GraphQLCredentialEntryID, GraphQLDocID, } from './identifiers.js';
 export type { ExtensionResolvers, SchemaBuilderParams, SharedDefinitions, } from './schema.js';
 export { createSchema, SchemaBuilder } from './schema.js';
 export type * from './types.js';

package/lib/index.js

@@ -4,5 +4,5 @@
 // list silently breaks resolver typing (`TS2339: Property '<name>' does not
 // exist on type 'Context'`).
 export { createReadContext } from './context.js';
-export { GraphQLAttachmentID, GraphQLDocID } from './identifiers.js';
+export { GraphQLAttachmentID, GraphQLCredentialEntryID, GraphQLDocID } from './identifiers.js';
 export { createSchema, SchemaBuilder } from './schema.js';

package/lib/schema.d.ts

@@ -194,6 +194,7 @@ export declare class SchemaBuilder {
     _buildArray(schema: ArrayModel, parentName?: string): GraphQLList<GraphQLNonNull<GraphQLOutputType>>;
     _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;
     _buildRelationFields(fields: GraphQLFieldConfigMap<DocumentNode, Context>, fieldName: string, relation: RelationField): void;
     _buildRelationSubscriptions(fields: GraphQLFieldConfigMap<unknown, Context>, modelID: string, fieldName: string, relation: RelationField): void;
     _buildString(schema: StringModel, parentName: string): GraphQLEnumType | GraphQLObjectType | GraphQLScalarType;

package/lib/schema.js

@@ -4,7 +4,7 @@ import { pascalCase } from 'change-case';
 import { extendSchema, GraphQLBoolean, GraphQLEnumType, GraphQLFloat, GraphQLID, GraphQLInputObjectType, GraphQLInt, GraphQLInterfaceType, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLSchema, GraphQLString, isEnumType, isListType, isNonNullType, isObjectType, isScalarType, Kind, parse as parseGraphQL } from 'graphql';
 import { connectionArgs, connectionDefinitions, mutationWithClientMutationId, nodeDefinitions } from 'graphql-relay';
 import { GraphQLDateTimeISO, GraphQLDID, GraphQLDuration, GraphQLEmailAddress, GraphQLJSON, GraphQLJSONObject } from 'graphql-scalars';
-import { GraphQLAttachmentID, GraphQLDocID } from './identifiers.js';
+import { GraphQLAttachmentID, GraphQLCredentialEntryID, GraphQLDocID } from './identifiers.js';
 import { GraphQLURL } from './scalars.js';
 import { getUniqueDocValue, validateAccessIdentifiers } from './utils.js';
 /**
@@ -44,9 +44,13 @@ const STRING_FORMATS = {
 };
 const STRING_TITLES = {
     attachmentid: GraphQLAttachmentID,
+    credentialentryid: GraphQLCredentialEntryID,
     did: GraphQLDID,
     docid: GraphQLDocID
 };
+function isAttachmentIDString(schema) {
+    return schema.type === 'string' && schema.title?.toLowerCase() === 'attachmentid';
+}
 function getReferenceID(path) {
     return path.slice(REFERENCE_PREFIX.length);
 }
@@ -105,7 +109,7 @@ function createEnumValueFilterInput(type) {
         }
     });
 }
-function createScalarValueFilterInput(type) {
+function createScalarValueFilterInput(type, options = {}) {
     return new GraphQLInputObjectType({
         name: `${type.name}ValueFilter`,
         isOneOf: true,
@@ -136,6 +140,37 @@ function createScalarValueFilterInput(type) {
             },
             greaterThanOrEqualTo: {
                 type
+            },
+            // Substring match only makes sense against string-backed scalars.
+            ...options.stringBacked ? {
+                contains: {
+                    type: GraphQLString
+                }
+            } : {}
+        }
+    });
+}
+// Opaque identifiers (DID, DocumentID, AttachmentID): equality only, no ordering
+// or substring match — the underlying strings are content-addressed, not text.
+function createExactValueFilterInput(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)
             }
         }
     });
@@ -159,6 +194,7 @@ const VALUE_FILTER_INPUTS = {
             }
         }
     }),
+    AttachmentIDValueFilter: createExactValueFilterInput(GraphQLAttachmentID),
     BooleanValueFilter: new GraphQLInputObjectType({
         name: 'BooleanValueFilter',
         isOneOf: true,
@@ -171,16 +207,26 @@ const VALUE_FILTER_INPUTS = {
             }
         }
     }),
+    DIDValueFilter: createExactValueFilterInput(GraphQLDID),
+    DocumentIDValueFilter: createExactValueFilterInput(GraphQLDocID),
     FloatValueFilter: createScalarValueFilterInput(GraphQLFloat),
     IntValueFilter: createScalarValueFilterInput(GraphQLInt),
-    StringValueFilter: createScalarValueFilterInput(GraphQLString)
+    StringValueFilter: createScalarValueFilterInput(GraphQLString, {
+        stringBacked: true
+    })
 };
+// Keyed by `scalar.name` (the GraphQL type name, e.g. "DID"), not the import
+// binding — keying by binding name silently never matched here before, since
+// scalars are looked up by `scalar.name`. `_owner` bypasses this map entirely
+// (hardcoded to AccountValueFilter), so it is not listed here.
 const VALUE_FILTER_INPUT_TYPES = {
-    GraphQLBoolean: 'BooleanValueFilter',
-    GraphQLDID: 'AccountValueFilter',
-    GraphQLFloat: 'FloatValueFilter',
-    GraphQLInt: 'IntValueFilter',
-    GraphQLString: 'StringValueFilter'
+    AttachmentID: 'AttachmentIDValueFilter',
+    Boolean: 'BooleanValueFilter',
+    DID: 'DIDValueFilter',
+    DocumentID: 'DocumentIDValueFilter',
+    Float: 'FloatValueFilter',
+    Int: 'IntValueFilter',
+    String: 'StringValueFilter'
 };
 const PatchSetOperation = new GraphQLInputObjectType({
     name: 'PatchSetOperation',
@@ -247,6 +293,26 @@ const OrderByDirection = new GraphQLEnumType({
         }
     }
 });
+const ArrayPresence = new GraphQLEnumType({
+    name: 'ArrayPresence',
+    values: {
+        NULL: {
+            value: 'null'
+        },
+        NON_NULL: {
+            value: 'nonNull'
+        },
+        EMPTY: {
+            value: 'empty'
+        },
+        NON_EMPTY: {
+            value: 'nonEmpty'
+        },
+        NULL_OR_EMPTY: {
+            value: 'nullOrEmpty'
+        }
+    }
+});
 const AccessRule = new GraphQLObjectType({
     name: 'AccessRule',
     fields: {
@@ -2161,16 +2227,34 @@ export class SchemaBuilder {
         if (schema.type === 'array') {
             const name = this._aliases[id] ?? pascalCase(parentName + schema.title);
             refParentName = name;
-            // const itemType = this._buildReferenceFilterInput(schema.items.$ref, schema.title)
+            const itemID = getReferenceID(schema.items.$ref);
+            const itemSchema = this._getReferenceSchema(itemID);
+            // Membership ops need a scalar item type; array-of-object/array-of-array items
+            // fall back to `isNull`-only filtering (no `_buildScalar` support for them).
+            if (itemSchema.type === 'object' || itemSchema.type === 'array') {
+                return new GraphQLInputObjectType({
+                    name: `${name}Filter`,
+                    isOneOf: true,
+                    fields: {
+                        isNull: {
+                            type: GraphQLBoolean
+                        }
+                    }
+                });
+            }
+            const itemScalar = this._buildScalar(itemID, itemSchema, name);
             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
+                    includesAll: {
+                        type: toList(itemScalar)
+                    },
+                    includesAny: {
+                        type: toList(itemScalar)
+                    },
+                    presence: {
+                        type: ArrayPresence
                     }
                 }
             });
@@ -2180,7 +2264,9 @@ export class SchemaBuilder {
         if (knownFilter != null) {
             return this._inputObjects[knownFilter];
         }
-        const filter = isEnumType(scalar) ? createEnumValueFilterInput(scalar) : createScalarValueFilterInput(scalar);
+        const filter = isEnumType(scalar) ? createEnumValueFilterInput(scalar) : createScalarValueFilterInput(scalar, {
+            stringBacked: true
+        });
         if (this._inputObjects[filter.name] == null) {
             this._inputObjects[filter.name] = filter;
         }
@@ -2357,6 +2443,11 @@ export class SchemaBuilder {
             if (fieldRef == null) {
                 throw new Error(`Missing ref for field ${key} of object ${id}`);
             }
+            const attachmentField = this._buildNestedAttachmentField(key, fieldRef);
+            if (attachmentField != null) {
+                fields[key] = attachmentField;
+                continue;
+            }
             const type = this._getReference(fieldRef, parentName);
             fields[key] = {
                 type: required.includes(key) ? new GraphQLNonNull(type) : type
@@ -2364,6 +2455,24 @@ export class SchemaBuilder {
         }
         return fields;
     }
+    // An attachmentid leaf nested inside an object is exposed as the AttachmentNode
+    // object rather than a bare AttachmentID scalar, so state/mimeType/contentLength
+    // resolve — mirroring the top-level attachment convenience fields. Always
+    // nullable (like the top-level fields): the value may be absent, e.g. an
+    // attachment not yet imported. Returns null for non-attachment fields.
+    _buildNestedAttachmentField(key, fieldRef) {
+        const refSchema = this._getReferenceSchema(getReferenceID(fieldRef));
+        if (!isAttachmentIDString(refSchema)) {
+            return null;
+        }
+        return {
+            type: this._getDefinitions().attachmentObject,
+            resolve: (source)=>{
+                const value = source[key];
+                return value ? AttachmentID.fromString(value) : null;
+            }
+        };
+    }
     _buildRelationFields(fields, fieldName, relation) {
         if (relation.isList) {
             // DB does not support matches for array containing values

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubun/graphql",
-  "version": "0.12.0",
+  "version": "0.13.1",
   "keywords": [],
   "license": "see LICENSE.md",
   "sideEffects": false,
@@ -22,20 +22,24 @@
     "change-case": "^5.4.4",
     "graphql": "^16.14.2",
     "graphql-relay": "^0.10.2",
-    "graphql-scalars": "^1.25.0",
+    "graphql-scalars": "^2.0.0",
     "multiformats": "^14.0.5",
-    "@kubun/id": "^0.12.0",
-    "@kubun/logger": "^0.12.0",
-    "@kubun/protocol": "^0.12.0",
-    "@kubun/hlc": "^0.12.0"
+    "@kubun/hlc": "^0.13.0",
+    "@kubun/logger": "^0.13.0",
+    "@kubun/id": "^0.13.0",
+    "@kubun/protocol": "^0.13.1"
   },
   "devDependencies": {
-    "@kokuin/capability": "^0.2.1",
-    "@kokuin/token": "^0.3.0",
-    "@kubun/db": "^0.12.0",
-    "@kubun/store-graph": "^0.12.0",
-    "@kubun/test-utils": "^0.12.0",
-    "@kubun/db-better-sqlite": "^0.12.0"
+    "@kokuin/capability": "^0.3.0",
+    "@kokuin/token": "^0.5.0",
+    "@kubun/db": "^0.13.0",
+    "@kubun/db-better-sqlite": "^0.13.0",
+    "@kubun/scalars": "^0.13.0",
+    "@kubun/store-graph": "^0.13.1",
+    "@kubun/test-utils": "^0.13.0"
+  },
+  "publishConfig": {
+    "access": "public"
   },
   "scripts": {
     "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",