@loradb/lora-graphql 0.16.2

package/dist/migrate.d.ts

@@ -0,0 +1,8 @@
+import { DocumentNode } from 'graphql';
+export interface MigrationResult {
+    /** The rewritten SDL. */
+    typeDefs: string;
+    /** What has no equivalent or needs a decision, by type and field. */
+    todos: string[];
+}
+export declare function migrateNeo4j(sdl: string, operations?: DocumentNode[]): MigrationResult;

package/dist/model/build.d.ts

@@ -0,0 +1,25 @@
+import { DocumentNode, GraphQLNamedType } from 'graphql';
+import { GraphModel, ScalarType } from './types.js';
+export interface ModelOptions {
+    /** Page size used when a list or connection gets no `limit` / `first`. */
+    defaultLimit?: number;
+    /** Hard cap on any page size; `@limit(max:)` may only lower it. */
+    maxLimit?: number;
+    /**
+     * Sign cursors with HMAC-SHA-256 under this secret, and reject cursors
+     * whose signature does not match. Without it cursors are only tagged
+     * with their sort. Changing the secret invalidates every cursor.
+     */
+    cursorSecret?: string;
+}
+export declare const DEFAULT_LIMIT = 25;
+export declare const MAX_LIMIT = 100;
+/**
+ * Parse and validate annotated type definitions into a `GraphModel`.
+ * Throws a `ModelError` listing every problem found.
+ */
+export declare function buildModel(typeDefs: string | DocumentNode, options?: ModelOptions): GraphModel;
+/** A custom scalar's storage type, from its `@storedAs(type:)`. */
+export declare function storageOf(t: GraphQLNamedType): ScalarType | undefined;
+export declare function lowerFirst(s: string): string;
+export declare function defaultPlural(typeName: string): string;

package/dist/model/cypher-lexer.d.ts

@@ -0,0 +1,10 @@
+export interface ParamRef {
+    name: string;
+    start: number;
+    end: number;
+}
+export declare function scanParams(text: string): ParamRef[];
+/** Replace every `$name` with `$<rename(name)>`. */
+export declare function renameParams(text: string, rename: (name: string) => string): string;
+/** Code outside strings and comments, uppercased, for construct checks. */
+export declare function codeOnly(text: string): string;

package/dist/model/directives.d.ts

@@ -0,0 +1,3 @@
+export declare const directiveTypeDefs = "\n  \"A node label set. Defaults to the type name.\"\n  directive @node(labels: [String!], plural: String) on OBJECT\n\n  \"Natural key: required, unique and immutable; the tie-breaker of every sort and the anchor of cursors, global ids, updates and deletes. With generate: true, creates fill it with a UUID when the input leaves it out.\"\n  directive @key(generate: Boolean = false) on FIELD_DEFINITION\n\n  \"On an interface field: every implementation declares this relationship (with @relationship, possibly of different types or directions), so clients can select it on the interface.\"\n  directive @declareRelationship on FIELD_DEFINITION\n\n  \"Offer this field as a grouping key of <plural>Grouped (needs @query(aggregate: true)).\"\n  directive @groupBy on FIELD_DEFINITION\n\n  \"A field computed in JavaScript by the resolver passed in the resolvers option. requires is a selection on this type (for example name capacity) fetched in the same statement, so the resolver reads it from its source.\"\n  directive @customResolver(requires: String) on FIELD_DEFINITION\n\n  \"On a custom scalar: how its values are stored. Filters, sorts and indexes follow the storage type; the scalar is passed through unless the scalars option supplies an implementation.\"\n  directive @storedAs(type: StorageType!) on SCALAR\n\n  enum StorageType {\n    STRING\n    INT\n    FLOAT\n    BOOLEAN\n    DATETIME\n    DATE\n  }\n\n  \"A uniqueness constraint.\"\n  directive @unique on FIELD_DEFINITION\n\n  \"An explicit index. Usually unnecessary: inferred from @filterable and @sortable.\"\n  directive @index(kind: IndexKind!) on FIELD_DEFINITION\n\n  \"An edge. The target type is the field's type.\"\n  directive @relationship(\n    type: String!\n    direction: RelationshipDirection!\n    properties: String\n    \"UNDIRECTED reads follow the relationship both ways; writes use direction.\"\n    queryDirection: QueryDirection = DIRECTED\n    \"What deleting this node does to nodes reached through the field.\"\n    onDelete: OnDelete = DETACH\n    \"Which nested writes mutation inputs offer for the field.\"\n    nestedOperations: [NestedOperation!] = [\n      CREATE\n      CONNECT\n      DISCONNECT\n      UPDATE\n      DELETE\n    ]\n    \"false: no aggregate on the field's connection and no aggregate filter.\"\n    aggregate: Boolean = true\n  ) on FIELD_DEFINITION\n\n  enum NestedOperation {\n    CREATE\n    CONNECT\n    DISCONNECT\n    UPDATE\n    DELETE\n  }\n\n  enum QueryDirection {\n    DIRECTED\n    UNDIRECTED\n  }\n\n  \"DETACH removes the relationships; CASCADE deletes the related nodes too; RESTRICT refuses while any exist.\"\n  enum OnDelete {\n    DETACH\n    CASCADE\n    RESTRICT\n  }\n\n  \"Which mutations may set the field. @readonly is onCreate: false, onUpdate: false.\"\n  directive @settable(\n    onCreate: Boolean = true\n    onUpdate: Boolean = true\n  ) on FIELD_DEFINITION\n\n  \"Whether the field can be read (onRead: false makes it write-only) or aggregated.\"\n  directive @selectable(\n    onRead: Boolean = true\n    onAggregate: Boolean = true\n  ) on FIELD_DEFINITION\n\n  \"Set by a callback passed to LoraGraphQL({ callbacks }) on these operations; never client-settable.\"\n  directive @populatedBy(\n    callback: String!\n    operations: [TimestampOperation!]! = [CREATE, UPDATE]\n  ) on FIELD_DEFINITION\n\n  \"The shape of the request's claims. Rules may only test declared claims.\"\n  directive @jwt on OBJECT\n\n  \"Where a declared claim lives in the token, e.g. app_metadata.roles.\"\n  directive @jwtClaim(path: String!) on FIELD_DEFINITION\n\n  \"Properties carried by a relationship type.\"\n  directive @relationshipProperties on OBJECT\n\n  \"API name differs from the stored property.\"\n  directive @alias(property: String!) on FIELD_DEFINITION\n\n  \"Stored, never exposed.\"\n  directive @private on FIELD_DEFINITION\n\n  \"Declared upper bound on a relationship's fan-out, used by cost estimates.\"\n  directive @cardinality(max: Int!) on FIELD_DEFINITION\n\n  \"Generated read operations for a node type. Reads are on by default.\"\n  directive @query(\n    read: Boolean = true\n    aggregate: Boolean = false\n  ) on OBJECT | INTERFACE | UNION\n\n  \"The plural of an interface or union, for its root field.\"\n  directive @plural(value: String!) on INTERFACE | UNION\n\n  \"Filter operators for a field. Without arguments: EQ and IN. On a relationship field: enables relationship filters.\"\n  directive @filterable(byValue: [FilterOperator!]) on FIELD_DEFINITION\n\n  \"Sort and keyset-paginate on this field.\"\n  directive @sortable on FIELD_DEFINITION\n\n  \"Page size bounds for lists of this type.\"\n  directive @limit(\n    default: Int\n    max: Int\n  ) on OBJECT | INTERFACE | UNION | FIELD_DEFINITION\n\n  \"Expose an opaque global id derived from this @key field.\"\n  directive @relayId on FIELD_DEFINITION\n\n  \"Full-text search over String fields: a FULLTEXT index and a search root field per entry.\"\n  directive @fulltext(indexes: [FulltextIndex!]!) on OBJECT\n\n  \"A vector embedding ([Float!]): a VECTOR index and a similarity root field.\"\n  directive @vector(\n    dimensions: Int!\n    similarity: VectorSimilarity = COSINE\n    queryName: String\n  ) on FIELD_DEFINITION\n\n  input FulltextIndex {\n    \"Index name. Default: <label>_search for the first, required after.\"\n    name: String\n    fields: [String!]!\n    analyzer: FulltextAnalyzer = STANDARD\n    \"Root field name. Default: search<Plural>, or search<Plural>By<Name>.\"\n    queryName: String\n  }\n\n  enum FulltextAnalyzer {\n    STANDARD\n    SIMPLE\n  }\n\n  enum VectorSimilarity {\n    COSINE\n    EUCLIDEAN\n  }\n\n  \"Generated subscriptions to changes made through the library. None without this directive.\"\n  directive @subscription(\n    operations: [MutationOperation!]! = [CREATE, UPDATE, DELETE]\n    \"Also send CONNECT and DISCONNECT events for the type's relationships.\"\n    relationships: Boolean = false\n    \"Send the stored values before an update or delete (one extra read per write).\"\n    previousState: Boolean = false\n  ) on OBJECT\n\n  \"Generated mutations for a node type. None without this directive.\"\n  directive @mutation(\n    operations: [MutationOperation!]! = [CREATE, UPDATE, DELETE]\n  ) on OBJECT\n\n  \"Value stored on create when the input leaves the field out.\"\n  directive @default(value: DefaultValue!) on FIELD_DEFINITION\n\n  \"Set to the current time by the listed operations; never client-settable.\"\n  directive @timestamp(\n    operations: [TimestampOperation!]! = [CREATE, UPDATE]\n  ) on FIELD_DEFINITION\n\n  \"Readable but never client-settable.\"\n  directive @readonly on FIELD_DEFINITION\n\n  \"A field backed by a Cypher statement. `this` is the parent node; arguments are $parameters, and $jwt holds the request's claims.\"\n  directive @cypher(statement: String!, columnName: String) on FIELD_DEFINITION\n\n  \"Require an authenticated request (a jwt in the context) for these operations.\"\n  directive @authentication(\n    operations: [AuthOperation!]! = [\n      READ\n      CREATE\n      UPDATE\n      DELETE\n      CREATE_RELATIONSHIP\n      DELETE_RELATIONSHIP\n      SUBSCRIBE\n    ]\n    \"Claims the request must also satisfy, such as a role in roles.\"\n    jwt: AuthorizationWhere\n  ) on OBJECT | FIELD_DEFINITION\n\n  \"Row-level rules over the node and the request's claims, compiled into the statements.\"\n  directive @authorization(\n    filter: [AuthorizationFilterRule!]\n    validate: [AuthorizationValidateRule!]\n  ) on OBJECT | FIELD_DEFINITION\n\n  input AuthorizationFilterRule {\n    operations: [AuthOperation!]! = [READ, UPDATE, DELETE]\n    requireAuthentication: Boolean = true\n    where: AuthorizationWhere!\n  }\n\n  input AuthorizationValidateRule {\n    operations: [AuthOperation!]! = [READ, CREATE, UPDATE, DELETE]\n    when: [AuthorizationWhen!]! = [BEFORE, AFTER]\n    requireAuthentication: Boolean = true\n    where: AuthorizationWhere!\n  }\n\n  enum MutationOperation {\n    CREATE\n    UPDATE\n    DELETE\n  }\n\n  enum TimestampOperation {\n    CREATE\n    UPDATE\n  }\n\n  enum AuthOperation {\n    READ\n    CREATE\n    UPDATE\n    DELETE\n    CREATE_RELATIONSHIP\n    DELETE_RELATIONSHIP\n    SUBSCRIBE\n  }\n\n  enum AuthorizationWhen {\n    BEFORE\n    AFTER\n  }\n\n  \"Any literal.\"\n  scalar DefaultValue\n\n  \"{ node: <Type>Where-shaped filter, jwt: claim filter, AND, OR, NOT }. String values starting with $jwt. are replaced by claims.\"\n  scalar AuthorizationWhere\n\n  enum IndexKind {\n    RANGE\n    TEXT\n    POINT\n  }\n\n  enum RelationshipDirection {\n    IN\n    OUT\n  }\n\n  enum FilterOperator {\n    EQ\n    IN\n    LT\n    LTE\n    GT\n    GTE\n    CONTAINS\n    STARTS_WITH\n    ENDS_WITH\n    WITHIN_BBOX\n    DISTANCE\n    INCLUDES\n    IS_NULL\n    CASE_INSENSITIVE\n  }\n\n  scalar BigInt\n  scalar Date\n  scalar Time\n  scalar LocalTime\n  scalar DateTime\n  scalar LocalDateTime\n  scalar Duration\n\n  type Point {\n    longitude: Float!\n    latitude: Float!\n    height: Float\n    srid: Int!\n    crs: String!\n  }\n\n  type CartesianPoint {\n    x: Float!\n    y: Float!\n    z: Float\n    srid: Int!\n    crs: String!\n  }\n";
+/** Names defined by the prelude; never treated as user types. */
+export declare const PRELUDE_TYPES: Set<string>;

package/dist/model/points.d.ts

@@ -0,0 +1,12 @@
+export declare function toLoraPoint(input: unknown): unknown;
+/**
+ * A stored value as the engine takes it: points converted, lists mapped,
+ * `@vector` fields tagged as VECTORs (a vector index skips plain lists).
+ */
+export declare function toStored(field: {
+    name: string;
+    type: string;
+    vector?: {
+        dimensions: number;
+    } | undefined;
+}, value: unknown): unknown;

package/dist/model/relations.d.ts

@@ -0,0 +1,7 @@
+import { AbstractType, GraphModel, RelationshipField } from './types.js';
+export declare function isPolymorphic(model: GraphModel, rel: RelationshipField): boolean;
+/** The field itself, or one concrete copy per member of its target. */
+export declare function memberFields(model: GraphModel, rel: RelationshipField): RelationshipField[];
+/** The declared field a member copy came from (or the field itself). */
+export declare function declared(rel: RelationshipField): RelationshipField;
+export declare function abstractOf(model: GraphModel, rel: RelationshipField): AbstractType | undefined;

package/dist/model/types.d.ts

@@ -0,0 +1,311 @@
+export type ScalarType = "String" | "ID" | "Int" | "Float" | "Boolean" | "BigInt" | "Date" | "Time" | "LocalTime" | "DateTime" | "LocalDateTime" | "Duration" | "Point" | "CartesianPoint"
+/** A user-declared enum, stored as its value name. */
+ | "Enum";
+export type FilterOperator = "EQ" | "IN" | "LT" | "LTE" | "GT" | "GTE" | "CONTAINS" | "STARTS_WITH" | "ENDS_WITH" | "WITHIN_BBOX" | "DISTANCE" | "INCLUDES" | "IS_NULL" | "CASE_INSENSITIVE";
+export type IndexKind = "RANGE" | "TEXT" | "POINT";
+export type MutationOperation = "CREATE" | "UPDATE" | "DELETE";
+export type AuthOperation = "READ" | MutationOperation | "CREATE_RELATIONSHIP" | "DELETE_RELATIONSHIP" | "SUBSCRIBE";
+/** Field-level options shared by every field kind. */
+interface FieldBase {
+    /** Operations on which reading this field needs an authenticated request. */
+    authentication: ReadonlySet<AuthOperation> | undefined;
+    /** Claims `@authentication(jwt:)` requires, when set. */
+    authenticationJwt?: AuthorizationWhere | undefined;
+    /** Field-level `@authorization` (validate rules only). */
+    authorization?: Authorization | undefined;
+}
+export interface ScalarField extends FieldBase {
+    kind: "scalar";
+    /** API field name. */
+    name: string;
+    /** Stored property name (differs from `name` under `@alias`). */
+    property: string;
+    type: ScalarType;
+    /** Enum type name when `type` is `Enum`. */
+    enumName: string | undefined;
+    /** The custom scalar clients see, when the field is one (`@storedAs`). */
+    customScalar?: string | undefined;
+    list: boolean;
+    required: boolean;
+    key: boolean;
+    unique: boolean;
+    private: boolean;
+    relayId: boolean;
+    filters: ReadonlySet<FilterOperator>;
+    sortable: boolean;
+    /** `@groupBy`: a grouping key of `<plural>Grouped`. */
+    groupBy: boolean;
+    /** Indexes requested explicitly with `@index`. */
+    indexes: readonly IndexKind[];
+    /** `@key(generate: true)`: creates fill a UUID when the input omits it. */
+    generate: boolean;
+    /** `@default(value:)`, stored on create when the input omits the field. */
+    defaultValue: {
+        value: unknown;
+    } | undefined;
+    /** `@timestamp`: set to the current time by these operations. */
+    timestamp: ReadonlySet<"CREATE" | "UPDATE"> | undefined;
+    /** Never client-settable (`@readonly`, `@timestamp`, `@private`). */
+    readonly: boolean;
+    /** `@settable`: which mutations may set it (both false when readonly). */
+    settableOn: {
+        create: boolean;
+        update: boolean;
+    };
+    /** `@selectable`: readable (false: write-only), and aggregatable. */
+    selectableOn: {
+        read: boolean;
+        aggregate: boolean;
+    };
+    /** `@populatedBy`: a named callback computes it on these operations. */
+    populatedBy: {
+        callback: string;
+        operations: ReadonlySet<"CREATE" | "UPDATE">;
+    } | undefined;
+    /**
+     * Set on the stand-in for a `@filterable` / `@sortable` `@cypher` field:
+     * its value is the statement's, computed per row, not a property.
+     */
+    computedBy?: CypherField;
+    /** `@vector`: stored as a VECTOR, searchable by similarity. */
+    vector: {
+        dimensions: number;
+        similarity: "COSINE" | "EUCLIDEAN";
+    } | undefined;
+    description: string | undefined;
+}
+export type NestedOperation = "CREATE" | "CONNECT" | "DISCONNECT" | "UPDATE" | "DELETE";
+export interface RelationshipField extends FieldBase {
+    kind: "relationship";
+    name: string;
+    /** Node type that declares the field. */
+    owner: string;
+    /** Relationship type, e.g. `IN_GENRE`. */
+    type: string;
+    direction: "IN" | "OUT";
+    /** Target node type name. */
+    target: string;
+    list: boolean;
+    required: boolean;
+    /** `@relationshipProperties` type name. */
+    properties: string | undefined;
+    /**
+     * The concrete @node types the field reaches: the target itself, or an
+     * interface's implementations / a union's members.
+     */
+    members: readonly string[];
+    /** For a member copy of a polymorphic field: the field it came from. */
+    via?: RelationshipField | undefined;
+    filterable: boolean;
+    /** UNDIRECTED: reads follow the relationship both ways. */
+    queryDirection: "DIRECTED" | "UNDIRECTED";
+    /** What deleting the owner does to nodes reached through the field. */
+    onDelete: "DETACH" | "CASCADE" | "RESTRICT";
+    /** Nested writes mutation inputs offer for the field. */
+    nestedOperations: ReadonlySet<NestedOperation>;
+    /** Whether the field's connection and filters offer aggregates. */
+    aggregate: boolean;
+    cardinality: number | undefined;
+    limit: PageLimit | undefined;
+    description: string | undefined;
+}
+/** How a `@cypher` field's value, or one of its arguments, is typed. */
+export interface TypeShape {
+    /** Named type: a scalar, enum or (for results) node type name. */
+    named: string;
+    list: boolean;
+    required: boolean;
+    itemRequired: boolean;
+}
+export interface CypherArgument {
+    name: string;
+    type: TypeShape;
+    defaultValue: unknown;
+    description: string | undefined;
+}
+export interface CypherField extends FieldBase {
+    kind: "cypher";
+    name: string;
+    /** Node type name, or `Query` / `Mutation` for root fields. */
+    owner: string;
+    statement: string;
+    /** The result column holding the field's value. */
+    columnName: string;
+    /** The field's type; `node` names a @node type when it returns nodes. */
+    type: TypeShape;
+    node: string | undefined;
+    /** An interface or union over @node types, when it returns those. */
+    abstract: string | undefined;
+    /** A plain object type (no @node), when it returns maps. */
+    object: string | undefined;
+    args: readonly CypherArgument[];
+    /** `$parameters` the statement uses, in order of first use. */
+    params: readonly string[];
+    /**
+     * `@filterable` / `@sortable`: a scalar stand-in for filters and sorts,
+     * whose value the statement computes per row (never through an index).
+     */
+    computed: ScalarField | undefined;
+    description: string | undefined;
+}
+/**
+ * A field computed in JavaScript (`@customResolver`): never stored or
+ * filtered; `requires` is fetched with the node so the resolver can use it.
+ */
+export interface CustomField extends FieldBase {
+    kind: "custom";
+    name: string;
+    owner: string;
+    /** Selection on the owner type, e.g. `name genre { name }`. */
+    requires: string | undefined;
+    type: TypeShape;
+    description: string | undefined;
+}
+export type Field = ScalarField | RelationshipField | CypherField | CustomField;
+/** `{ node, jwt, AND, OR, NOT }`, as written in `@authorization`. */
+export type AuthorizationWhere = Record<string, unknown>;
+export interface AuthorizationFilterRule {
+    operations: ReadonlySet<AuthOperation>;
+    requireAuthentication: boolean;
+    where: AuthorizationWhere;
+}
+export interface AuthorizationValidateRule {
+    operations: ReadonlySet<AuthOperation>;
+    when: ReadonlySet<"BEFORE" | "AFTER">;
+    requireAuthentication: boolean;
+    where: AuthorizationWhere;
+}
+export interface Authorization {
+    filter: readonly AuthorizationFilterRule[];
+    validate: readonly AuthorizationValidateRule[];
+}
+export interface PageLimit {
+    default: number;
+    max: number;
+}
+export interface NodeType {
+    name: string;
+    /** First label is the primary label every MATCH uses. */
+    labels: readonly string[];
+    /** Plural used for root fields, e.g. `festivals`. */
+    plural: string;
+    fields: ReadonlyMap<string, Field>;
+    key: ScalarField;
+    read: boolean;
+    aggregate: boolean;
+    /** Generated mutations; empty unless `@mutation`. */
+    mutations: ReadonlySet<MutationOperation>;
+    /** Change events to subscribe to; empty unless `@subscription`. */
+    subscriptions: ReadonlySet<MutationOperation>;
+    /** `@subscription(relationships:, previousState:)`. */
+    subscriptionOptions: {
+        relationships: boolean;
+        previousState: boolean;
+    };
+    limit: PageLimit;
+    /** Operations that need an authenticated request. */
+    authentication: ReadonlySet<AuthOperation> | undefined;
+    /** Claims `@authentication(jwt:)` requires, when set. */
+    authenticationJwt: AuthorizationWhere | undefined;
+    authorization: Authorization | undefined;
+    /** Full-text and vector indexes with their search root fields. */
+    search: readonly SearchIndex[];
+    /** Interfaces the type implements. */
+    interfaces: readonly string[];
+    description: string | undefined;
+}
+export type SearchIndex = {
+    kind: "fulltext";
+    name: string;
+    fields: readonly ScalarField[];
+    analyzer: "STANDARD" | "SIMPLE";
+    /** Root field, e.g. `searchFestivals`. */
+    queryName: string;
+} | {
+    kind: "vector";
+    name: string;
+    field: ScalarField;
+    dimensions: number;
+    similarity: "COSINE" | "EUCLIDEAN";
+    queryName: string;
+};
+/** An interface over @node types, or a union of them. */
+export interface AbstractType {
+    kind: "interface" | "union";
+    name: string;
+    /** Concrete @node types: implementations or members. */
+    members: readonly string[];
+    /** An interface's scalar fields, as declared on the interface. */
+    fields: ReadonlyMap<string, ScalarField>;
+    /**
+     * An interface's `@declareRelationship` fields: every implementation has
+     * a relationship field of that name, target and shape.
+     */
+    relationships: ReadonlyMap<string, DeclaredRelationship>;
+    plural: string;
+    read: boolean;
+    limit: PageLimit;
+    description: string | undefined;
+}
+export interface DeclaredRelationship {
+    name: string;
+    target: string;
+    list: boolean;
+    description: string | undefined;
+}
+/**
+ * An object type without @node, returned by @cypher fields as maps: its
+ * fields are read from the map's keys.
+ */
+export interface PlainObjectType {
+    name: string;
+    fields: ReadonlyMap<string, {
+        name: string;
+        type: TypeShape;
+    }>;
+    description: string | undefined;
+}
+export interface RelationshipPropertiesType {
+    name: string;
+    fields: ReadonlyMap<string, ScalarField>;
+    description: string | undefined;
+}
+export interface EnumType {
+    name: string;
+    values: ReadonlyArray<{
+        name: string;
+        description: string | undefined;
+    }>;
+    description: string | undefined;
+}
+export interface GraphModel {
+    nodes: ReadonlyMap<string, NodeType>;
+    /** Interfaces and unions over @node types. */
+    abstracts: ReadonlyMap<string, AbstractType>;
+    enums: ReadonlyMap<string, EnumType>;
+    relationshipProperties: ReadonlyMap<string, RelationshipPropertiesType>;
+    /** `@cypher` fields declared on `Query` and `Mutation`. */
+    queries: readonly CypherField[];
+    mutations: readonly CypherField[];
+    /** Problems that do not stop the model, e.g. an unused @cypher argument. */
+    warnings: readonly ModelWarning[];
+    /** Custom scalars (`@storedAs`), by name: their storage type. */
+    scalars: ReadonlyMap<string, ScalarType>;
+    /** Object types without @node that @cypher fields return. */
+    objects: ReadonlyMap<string, PlainObjectType>;
+    /** The `@jwt` claims shape, when declared: claim name → token path. */
+    jwt: ReadonlyMap<string, string> | undefined;
+    /** Secret cursors are signed with, when configured. */
+    cursorSecret: string | undefined;
+}
+export interface ModelWarning {
+    type: string;
+    field?: string;
+    message: string;
+}
+export declare function scalarFields(t: {
+    fields: ReadonlyMap<string, Field>;
+}): ScalarField[];
+export declare function cypherFields(t: NodeType): CypherField[];
+export declare function relationshipFields(t: NodeType): RelationshipField[];
+export {};

package/dist/observe.d.ts

@@ -0,0 +1,72 @@
+import { QueryResult, Statement } from './driver.js';
+export interface StatementEndEvent {
+    /** The root field the statements belong to. */
+    field: string;
+    /** Statements run in one call: reads batch theirs, writes run one by one. */
+    statements: Statement[];
+    mode: "read" | "write";
+    durationMs: number;
+    /** Rows returned, over every statement. */
+    rows: number;
+    /** Set when the statements failed. */
+    error?: unknown;
+    /** Estimated rows touched, for reads (the `maxCost` estimate). */
+    cost?: number;
+    operationName?: string;
+    /** Id of the persisted operation, when the request used one. */
+    persistedId?: string;
+}
+export interface SpanLike {
+    setAttribute(key: string, value: string | number | boolean): unknown;
+    setStatus(status: {
+        code: number;
+        message?: string;
+    }): unknown;
+    recordException(exception: Error | string): unknown;
+    end(): void;
+}
+export interface TracerLike {
+    startActiveSpan<T>(name: string, fn: (span: SpanLike) => T): T;
+}
+export interface MetricsLike {
+    counter(name: string, value: number, attributes?: Attributes): void;
+    histogram(name: string, value: number, attributes?: Attributes): void;
+}
+export type Attributes = Record<string, string | number | boolean>;
+export interface ObservabilityOptions {
+    /** Called after every statement (or batch of read statements). */
+    onStatementEnd?: (event: StatementEndEvent) => void;
+    /**
+     * Emits a `lora.graphql.field` span per root field, containing a
+     * `lora.cypher` span per statement call.
+     */
+    tracer?: TracerLike;
+    /** Put the Cypher text in spans as `db.statement`. Default false. */
+    traceStatements?: boolean;
+    /**
+     * Receives `lora.graphql.statements` (counter), `lora.graphql.errors`
+     * (counter), `lora.graphql.statement.duration` (ms) and
+     * `lora.graphql.cost` (estimated rows) histograms.
+     */
+    metrics?: MetricsLike;
+}
+/** What a statement call is part of. */
+export interface StatementMeta {
+    field: string;
+    mode: "read" | "write";
+    cost?: number | undefined;
+    operationName?: string | undefined;
+    persistedId?: string | undefined;
+}
+export declare class Observer {
+    #private;
+    constructor(options: ObservabilityOptions);
+    get active(): boolean;
+    /** Run a root field's resolver inside its span. */
+    field<T>(meta: {
+        field: string;
+        operationName?: string | undefined;
+    }, fn: () => Promise<T>): Promise<T>;
+    /** Run statements, timing them and reporting the outcome. */
+    statements<T extends QueryResult | QueryResult[]>(meta: StatementMeta, statements: Statement[], run: () => Promise<T>): Promise<T>;
+}

package/dist/schema/build.d.ts

@@ -0,0 +1,38 @@
+import { GraphQLSchema, GraphQLFieldResolver, GraphQLResolveInfo, GraphQLScalarType } from 'graphql';
+import { RootKind } from '../compile/read.js';
+import { AbstractType, CustomField, CypherField, GraphModel, NodeType, SearchIndex } from '../model/types.js';
+import { MutationResolver } from './mutations.js';
+/** One event of a generated subscription. */
+export interface ChangeEvent {
+    operation: "CREATE" | "UPDATE" | "DELETE" | "CONNECT" | "DISCONNECT";
+    key: unknown;
+    /** When the write was committed, ISO-8601. */
+    timestamp?: string | undefined;
+    /** For CONNECT / DISCONNECT: the relationship and its other end. */
+    relationship?: {
+        field: string;
+        type: string;
+        relatedType: string;
+        relatedKey: unknown;
+    } | undefined;
+    /** Stored properties before the write (`previousState: true`). */
+    previous?: Record<string, unknown> | undefined;
+}
+export interface SchemaHooks {
+    resolveAbstract: (abstract: AbstractType, info: GraphQLResolveInfo, context: unknown) => Promise<unknown>;
+    subscribe: (node: NodeType, args: Record<string, unknown>, context: unknown) => AsyncIterable<ChangeEvent>;
+    resolveChangedNode: (node: NodeType, event: ChangeEvent, info: GraphQLResolveInfo, context: unknown) => Promise<unknown>;
+    /** Implementations of custom scalars, by name (the scalars option). */
+    scalars?: Readonly<Record<string, GraphQLScalarType>> | undefined;
+    /** The resolver of a `@customResolver` field (from the resolvers option). */
+    customResolver: (node: NodeType, field: CustomField) => GraphQLFieldResolver<Record<string, unknown>, unknown>;
+    resolveSearch: (node: NodeType, index: SearchIndex, info: GraphQLResolveInfo, context: unknown, connection: boolean) => Promise<unknown>;
+    resolveRoot: RootResolver;
+    resolveNode: NodeResolver;
+    resolveCypher: CypherRootResolver;
+    resolveMutation: MutationResolver;
+}
+export type CypherRootResolver = (field: CypherField, info: GraphQLResolveInfo, context: unknown) => Promise<unknown>;
+export type RootResolver = (kind: RootKind, node: NodeType, info: GraphQLResolveInfo, context: unknown) => Promise<unknown>;
+export type NodeResolver = (id: string, info: GraphQLResolveInfo, context: unknown) => Promise<unknown>;
+export declare function buildSchema(model: GraphModel, hooks: SchemaHooks): GraphQLSchema;

package/dist/schema/global-id.d.ts

@@ -0,0 +1,6 @@
+/** Opaque global id: the type name and @key value. */
+export declare function toGlobalId(type: string, key: unknown): string;
+export declare function fromGlobalId(id: string): {
+    type: string;
+    key: string | number;
+} | undefined;

package/dist/schema/guard.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Nodes carrying `__authorized: false` failed an `@authorization`
+ * validate rule for READ: reading them is an error, not an empty result.
+ */
+export declare function assertReadable<T>(value: T): T;

package/dist/schema/mutations.d.ts

@@ -0,0 +1,44 @@
+import { GraphQLObjectType, GraphQLFieldConfigMap, GraphQLInputType, GraphQLResolveInfo } from 'graphql';
+import { GraphModel, MutationOperation, NodeType, ScalarField } from '../model/types.js';
+/** A generated mutation: the single-node ones, and the bulk ones by where. */
+export type MutationKind = MutationOperation | "UPSERT" | "UPDATE_MANY" | "DELETE_MANY";
+export type MutationResolver = (operation: MutationKind, node: NodeType, info: GraphQLResolveInfo, context: unknown) => Promise<unknown>;
+export declare const mutationNames: {
+    create: (t: NodeType) => string;
+    update: (t: NodeType) => string;
+    delete: (t: NodeType) => string;
+    upsert: (t: NodeType) => string;
+    updateMany: (t: NodeType) => string;
+    deleteMany: (t: NodeType) => string;
+    upsertInput: (t: string) => string;
+    upsertPayload: (t: NodeType) => string;
+    createInput: (t: string) => string;
+    updateInput: (t: string) => string;
+    adjustInput: (t: string) => string;
+    createPayload: (t: NodeType) => string;
+    updatePayload: (t: NodeType) => string;
+    updateManyPayload: (t: NodeType) => string;
+    relationCreate: (t: string, f: string) => string;
+    relationUpdate: (t: string, f: string) => string;
+    connect: (t: string, f: string) => string;
+    nestedCreate: (t: string, f: string) => string;
+    nestedUpdate: (t: string, f: string) => string;
+    /** Payload field holding the created nodes / the updated node. */
+    createdField: (t: NodeType) => string;
+    updatedField: (t: NodeType) => string;
+};
+export interface MutationSchemaContext {
+    model: GraphModel;
+    object: (typeName: string) => GraphQLObjectType;
+    inputType: (f: ScalarField) => GraphQLInputType;
+    where: (typeName: string) => GraphQLInputType;
+}
+/** Whether clients may set a field on `op` (`@settable`, `@readonly`, …). */
+export declare function settable(f: ScalarField, op: "CREATE" | "UPDATE"): boolean;
+/** Whether the create input must carry the field. */
+export declare function requiredOnCreate(f: ScalarField): boolean;
+/** A type with nothing settable after create has no update. */
+export declare function isUpdatable(node: NodeType): boolean;
+/** Numeric and list fields take operators in `adjust`. */
+export declare function adjustable(f: ScalarField): boolean;
+export declare function buildMutations(ctx: MutationSchemaContext, resolve: MutationResolver): GraphQLFieldConfigMap<unknown, unknown>;

package/dist/schema/names.d.ts

@@ -0,0 +1,37 @@
+import { NodeType, RelationshipField } from '../model/types.js';
+export declare const upperFirst: (s: string) => string;
+export declare const names: {
+    where: (type: string) => string;
+    fieldFilter: (type: string, field: string) => string;
+    sort: (type: string) => string;
+    connection: (type: string) => string;
+    edge: (type: string) => string;
+    aggregate: (type: string) => string;
+    match: (type: string) => string;
+    searchConnection: (type: string) => string;
+    searchEdge: (type: string) => string;
+    relationFilter: (type: string, field: string) => string;
+    relConnection: (type: string, field: string) => string;
+    relEdge: (type: string, field: string) => string;
+    relConnectionWhere: (type: string, field: string) => string;
+    connectionField: (field: string) => string;
+    listRoot: (t: NodeType) => string;
+    connectionRoot: (t: NodeType) => string;
+    aggregateRoot: (t: NodeType) => string;
+    groupedRoot: (t: NodeType) => string;
+    singleRoot: (t: NodeType) => string;
+};
+/**
+ * Whether a list relationship gets its own connection/edge types (and a
+ * `{ node, edge }` where): it has relationship properties.
+ */
+export declare function hasOwnConnection(rel: RelationshipField): boolean;
+/**
+ * The connection and edge type names of a list relationship's connection:
+ * its own when it has properties or aggregates (whose count covers
+ * relationships too) or opts out of them, the target's otherwise.
+ */
+export declare function connectionTypeNames(rel: RelationshipField, target: NodeType): {
+    connection: string;
+    edge: string;
+};

package/dist/schema/scalars.d.ts

@@ -0,0 +1,9 @@
+import { GraphQLScalarType } from 'graphql';
+export declare const GraphQLDate: GraphQLScalarType<unknown, unknown>;
+export declare const GraphQLTime: GraphQLScalarType<unknown, unknown>;
+export declare const GraphQLLocalTime: GraphQLScalarType<unknown, unknown>;
+export declare const GraphQLDateTime: GraphQLScalarType<unknown, unknown>;
+export declare const GraphQLLocalDateTime: GraphQLScalarType<unknown, unknown>;
+export declare const GraphQLDuration: GraphQLScalarType<unknown, unknown>;
+export declare const GraphQLBigInt: GraphQLScalarType<number | bigint, string>;
+export declare const CUSTOM_SCALARS: Record<string, GraphQLScalarType>;

package/dist/testing.d.ts

@@ -0,0 +1,36 @@
+import { DocumentNode, ExecutionResult, GraphQLSchema } from 'graphql';
+import { LoraDatabaseLike } from './driver.js';
+import { LoraGraphQL, LoraGraphQLOptions, StatementEvent } from './lora-graphql.js';
+/** The node binding's database, as far as tests use it. */
+export type TestDatabase = LoraDatabaseLike & {
+    execute(query: string, params?: never): Promise<unknown>;
+    dispose?(): void;
+};
+export interface TestLoraGraphQLOptions extends Omit<LoraGraphQLOptions, "driver"> {
+    /** Cypher to run after the schema is asserted, or a function given the database. */
+    seed?: string | string[] | ((db: TestDatabase) => Promise<void>);
+}
+export interface TestLoraGraphQL {
+    lora: LoraGraphQL;
+    db: TestDatabase;
+    schema: GraphQLSchema;
+    /** Every statement run so far (clear with `statements.length = 0`). */
+    statements: StatementEvent[];
+    /** Execute a document; errors stay in the result. */
+    run: (source: string, variables?: Record<string, unknown>, context?: Record<string, unknown>) => Promise<ExecutionResult>;
+    /** Execute a document and return its data; throws on the first error. */
+    data: <T = Record<string, unknown>>(source: string, variables?: Record<string, unknown>, context?: Record<string, unknown>) => Promise<T>;
+    /** Release the database. */
+    close: () => void;
+}
+/** A LoraGraphQL over a fresh in-memory database, schema asserted and seeded. */
+export declare function createTestLoraGraphQL(options: TestLoraGraphQLOptions): Promise<TestLoraGraphQL>;
+/**
+ * Assert that every statement of a query's root fields uses the index
+ * access it was compiled for (no label scans where a seek was expected,
+ * no mutating plans, no row-budget excess). Throws listing each finding.
+ */
+export declare function expectSeeks(lora: LoraGraphQL, document: string | DocumentNode, variables?: Record<string, unknown>, options?: {
+    rowBudget?: number;
+    context?: unknown;
+}): Promise<void>;