@loradb/lora-graphql 0.23.0 → 0.24.1

package/dist/lora-graphql.d.ts

@@ -1,331 +1,17 @@
-import { ExecutionArgs, DocumentNode, ExecutionResult, GraphQLSchema, GraphQLFieldResolver, GraphQLScalarType, ValidationRule } from 'graphql';
-import { CypherFinding } from './analyze/cypher-check.js';
+import { ExecutionArgs, DocumentNode, ExecutionResult, GraphQLSchema, ValidationRule } from 'graphql';
 import { SchemaRequirement } from './analyze/indexes.js';
 import { PlanReport } from './analyze/plans.js';
-import { AccessEntry, OperationAccess } from './analyze/access.js';
+import { OperationAccess } from './analyze/access.js';
+import { AccessEntry } from './analyze/verdicts.js';
 import { Statistics } from './analyze/statistics.js';
-import { CompiledRead, ReadSet } from './compile/read.js';
-import { LoraDriver, Statement } from './driver.js';
+import { CompiledRead, ReadSet } from './compile/read/types.js';
 import { WriteChange } from './execute/changes.js';
 import { LoraTransaction } from './execute/transaction.js';
-import { PopulatedByCallback } from './execute/mutate.js';
 import { OperationManifest } from './codegen.js';
-import { envelopPlugin, DocumentGuards } from './guards.js';
-import { ModelOptions } from './model/build.js';
-import { ObservabilityOptions } from './observe.js';
-import { GraphModel, ModelWarning } from './model/types.js';
-export interface LoraGraphQLOptions extends ModelOptions, ObservabilityOptions {
-    /** Annotated SDL: the graph model and the API in one document. */
-    typeDefs: string | DocumentNode;
-    driver: LoraDriver;
-    /** Timeout for every statement, in milliseconds. Default 10 000; 0 disables. */
-    timeoutMs?: number;
-    /**
-     * Time budget for all root fields of one query, in milliseconds: past
-     * it, the operation's statements are aborted and its unfinished fields
-     * fail with TIMEOUT. Default twice `timeoutMs` (20 000); 0 disables.
-     * Subscriptions are not bounded by it; mutations keep `timeoutMs` per
-     * statement.
-     */
-    operationTimeoutMs?: number;
-    /**
-     * Statements one operation runs at once: aliased root fields queue for
-     * a slot instead of taking every libuv worker, so one request cannot
-     * starve the others. Default 2.
-     */
-    maxConcurrentStatements?: number;
-    /**
-     * Approximate bytes the compile cache may hold, and again the parsed
-     * document cache: entries are evicted oldest first past it, besides the
-     * entry caps. Requests with more than 16 KiB of variables a field uses
-     * (long `in:` lists, embedding vectors) are compiled but not cached.
-     * Default 64 MiB.
-     */
-    compileCacheBytes?: number;
-    /**
-     * Reject a root field whose estimated rows touched exceed this, before
-     * it runs. The estimate multiplies page sizes through nested lists,
-     * capped by relationship degrees from `analyze()` or `@cardinality`,
-     * and charges each filter the rows it examines: a label scan when no
-     * index answers it, the related nodes of every relationship it follows.
-     * Default 50 000; `Infinity` disables.
-     */
-    maxCost?: number;
-    /**
-     * The cost limit for one request, from its context (for example by
-     * user or plan). Undefined falls back to `maxCost`.
-     */
-    budget?: (context: unknown) => number | undefined;
-    /** Called with every root field's cost estimate, before it runs. */
-    onCost?: (event: CostEvent) => void;
-    /**
-     * The request's verified claims, from the GraphQL context. Default:
-     * `context.jwt`. The library never verifies tokens: do that in the
-     * server and put the claims in the context.
-     */
-    jwt?: (context: unknown) => Record<string, unknown> | undefined;
-    /**
-     * Most nodes one mutation may create, update or delete, nested ones
-     * included (and ten times as many relationships written). Default 1000: larger imports belong in a Cypher load, not a GraphQL
-     * request. Also the default `limit` of bulk updates and deletes.
-     */
-    maxBatch?: number;
-    /**
-     * Most items a list argument of a `@cypher` field takes, unless its
-     * `@size(max:)` says otherwise. More is BAD_USER_INPUT before the
-     * statement runs. Default 1000.
-     */
-    maxListArgument?: number;
-    /**
-     * Relationship levels one `where` may nest: quantifiers (`some`,
-     * `none`, `all`, `single`, `count`, `aggregate`), connection filters,
-     * `<field>Exists` and filters through a single relationship each count
-     * one. Deeper is BAD_USER_INPUT before anything runs: each level
-     * multiplies the work by the relationship's degree. Default 2.
-     */
-    maxFilterDepth?: number;
-    /**
-     * Items an `in` filter operand may hold. More is BAD_USER_INPUT before
-     * anything runs. Default 1000.
-     */
-    maxListFilter?: number;
-    /**
-     * Characters a string filter operand (`eq`, `contains`, an `in` item, …)
-     * may hold. More is BAD_USER_INPUT before anything runs. Default 10 000.
-     */
-    maxStringFilter?: number;
-    /**
-     * Changes a `changes()` consumer or subscriber may fall behind before it
-     * is ended with an error. Default 1000.
-     */
-    maxQueuedChanges?: number;
-    /**
-     * Live subscriptions one scope (see `subscriptionScope`) may hold; one
-     * more is LIMIT_EXCEEDED. Default 100.
-     */
-    maxSubscriptions?: number;
-    /**
-     * What `maxSubscriptions` counts per: by default the context object, so
-     * a server that reuses one context per connection (graphql-ws) limits
-     * each connection. Return the connection (or user) otherwise.
-     */
-    subscriptionScope?: (context: unknown) => object | undefined;
-    /**
-     * How deep relationship filters may nest in a subscription's `where`,
-     * which runs on every change. Deeper is LIMIT_EXCEEDED. Default 1.
-     */
-    maxSubscriptionFilterDepth?: number;
-    /**
-     * Per statement a subscription runs to check a change (visibility,
-     * `where`, related nodes). Default 2000, or `timeoutMs` when lower.
-     */
-    subscriptionTimeoutMs?: number;
-    /** Named callbacks for `@populatedBy(callback:)`. */
-    callbacks?: Record<string, PopulatedByCallback>;
-    /**
-     * Implementations of custom scalars declared with `@storedAs`, e.g. one
-     * that validates e-mail addresses. Without one a scalar passes through.
-     */
-    scalars?: Record<string, GraphQLScalarType>;
-    /**
-     * Feed subscriptions and `changes()` from the engine's committed change
-     * feed (lora-node `db.changes()`): every write to the database, from
-     * any path in the process that owns it, in commit order. `onWrite`
-     * still reports this instance's mutations, and `previousState` needs
-     * them. Default false.
-     */
-    changeFeed?: boolean;
-    /**
-     * Resolvers of `@customResolver` fields, by type and field name. The
-     * source holds the node's selected fields plus the field's `requires`.
-     */
-    resolvers?: Record<string, Record<string, GraphQLFieldResolver<Record<string, unknown>, unknown>>>;
-    /** Called with every statement before it runs; for logging and tests. */
-    onStatement?: (event: StatementEvent) => void;
-    /**
-     * Hide database error details from clients: they get
-     * `extensions.code` `DATABASE_ERROR` and an `id`, and `onError` gets the
-     * engine's message. Default: on when `NODE_ENV` is `production`.
-     */
-    maskErrors?: boolean;
-    /** Called with every database error, masked or not. */
-    onError?: (event: DatabaseErrorEvent) => void;
-    /**
-     * Limits on the documents `execute()`, `subscribe()` and `persist()`
-     * accept: depth,
-     * aliases, root fields, tokens, introspection. `false` turns them off.
-     * For other servers use `validationRules()` or `envelopPlugin()`.
-     */
-    guards?: DocumentGuards | false;
-    /**
-     * Make `execute()` and `subscribe()` refuse `source` and run only
-     * persisted operations by `id`. Default false.
-     */
-    persistedOnly?: boolean;
-    /**
-     * How `execute()` commits a mutation with several root fields.
-     * `"field"` (the default): each root field in its own transaction, so a
-     * later failure leaves the earlier ones committed. `"operation"`: every
-     * root field in one transaction, committed only when the operation
-     * reports no error, rolled back (with `data: null`) otherwise. A
-     * `transaction` in the context takes precedence. Envelop / Yoga servers
-     * on `getSchema()` get the same with `lora.envelopPlugin()`; other
-     * servers calling graphql-js directly put a `lora.begin()` transaction
-     * in the context (without one, a one-time warning says each root field
-     * committed on its own).
-     */
-    mutationTransaction?: "field" | "operation";
-    /**
-     * Add `extensions.timing` to `execute()` results: the request's total
-     * time, the time spent in LoraDB, and both per root field, in
-     * milliseconds. `true` for every request, or a function deciding per
-     * request from the GraphQL context (for example only for admins or in
-     * development). Default off: timings sent to clients can act as a
-     * timing side channel.
-     */
-    timing?: boolean | ((context: unknown) => boolean);
-}
-/** `extensions.timing` of an `execute()` result (see the `timing` option). */
-export interface ExecutionTiming {
-    /** The whole `execute()` call: parse, validation, execution. */
-    totalMs: number;
-    /** Time spent running statements in LoraDB. */
-    databaseMs: number;
-    /** Per root field, by response key (alias or name). */
-    fields: Record<string, {
-        totalMs: number;
-        databaseMs: number;
-    }>;
-}
-export interface CostEvent {
-    field: string;
-    /** Estimated rows this root field touches. */
-    cost: number;
-    /** Estimated rows of the operation so far, this field included. */
-    total: number;
-    /** The limit that applies: `budget(context)` or `maxCost`. */
-    limit: number;
-    context: unknown;
-}
-export interface DatabaseErrorEvent {
-    /** Correlation id, also in the client error's `extensions.id`. */
-    id: string;
-    /**
-     * The root field that failed, or `changeFeed` for a failure of the
-     * change feed (it reopens from where it stopped after a backoff).
-     */
-    field: string;
-    /** The engine's message, which may name labels, properties and Cypher. */
-    message: string;
-    /** The error as thrown by the driver. */
-    error: unknown;
-}
-export interface StatementEvent {
-    field: string;
-    statement: Statement;
-}
-/** Per-request options read from the GraphQL context, when present. */
-export interface LoraGraphQLContext {
-    /** Verified claims; enables @authentication and @authorization. */
-    jwt?: Record<string, unknown>;
-    /** Cancels the request's statements when aborted. */
-    signal?: AbortSignal;
-    /**
-     * Run in this transaction (from `lora.begin()`) instead of one per
-     * field: the caller commits, together with its own Cypher.
-     */
-    transaction?: LoraTransaction;
-}
-export interface AssertSchemaOptions {
-    /** Create what is missing instead of only reporting it. */
-    create?: boolean;
-}
-export interface SchemaAssertion {
-    required: SchemaRequirement[];
-    missing: SchemaRequirement[];
-    created: SchemaRequirement[];
-    /**
-     * Full-text and vector indexes present under their name but defined
-     * differently (labels, properties, kind): search would keep using the
-     * old definition. Without `create`; with it they are re-created.
-     */
-    mismatched: SchemaRequirement[];
-    /** Indexes `create` dropped and created again with the model's definition. */
-    recreated: SchemaRequirement[];
-}
-export interface CheckOptions {
-    /**
-     * Flag statements whose largest engine row estimate (from graph
-     * statistics) exceeds this. Off by default: estimates ignore a LIMIT
-     * that stops an index-ordered scan early.
-     */
-    rowBudget?: number;
-    /**
-     * Operations to compile and plan-check (S2), with example variables and
-     * the GraphQL context to compile them under (e.g. `{ jwt }`, so rules
-     * compile as they do for a signed-in caller). Without one, an operation
-     * compiles as an anonymous request would.
-     */
-    operations?: Array<{
-        name?: string;
-        document: string | DocumentNode;
-        variables?: Record<string, unknown>;
-        context?: unknown;
-    }>;
-}
-export interface CheckReport {
-    /** True when nothing below is a failure. */
-    ok: boolean;
-    /** Model warnings, e.g. an unused @cypher argument. */
-    warnings: readonly ModelWarning[];
-    /** @cypher statements the engine rejects or that write from a query. */
-    cypher: CypherFinding[];
-    /** Constraints and indexes the database lacks. */
-    missing: SchemaRequirement[];
-    /** Indexes the database has that no part of the API needs. */
-    unused: Array<{
-        name: string;
-        type: string;
-        labels: string[];
-        properties: string[];
-    }>;
-    /** Schema lint: valid but costly or risky choices (not failures). */
-    lint: readonly ModelWarning[];
-    /**
-     * `@mutation` types with writes no rule guards (failures): declare them
-     * with `@authorization(public: [...])` when that is intended.
-     */
-    security: readonly ModelWarning[];
-    /** Plan findings per operation and root field. */
-    plans: Array<{
-        operation: string;
-        field: string;
-        reports: PlanReport[];
-    }>;
-    /** Operations that failed to compile. */
-    errors: Array<{
-        operation: string;
-        message: string;
-    }>;
-}
-export interface ExecuteArgs {
-    /** The document, or `id` of a persisted operation. */
-    source?: string;
-    id?: string;
-    variables?: Record<string, unknown>;
-    operationName?: string;
-    context?: unknown;
-    /**
-     * Attach the operation's read-set to the result as a non-enumerable
-     * `readSet` property (never serialized to the client), for a response
-     * cache to invalidate with `lora.affects(result.readSet, change)`.
-     */
-    readSet?: boolean;
-}
-/** `execute()`'s result; `readSet` is there when `ExecuteArgs.readSet` asked. */
-export type LoraExecutionResult = ExecutionResult & {
-    readonly readSet?: ReadSet;
-};
+import { envelopPlugin } from './guards.js';
+import { GraphModel } from './model/types.js';
+import { AssertSchemaOptions, CheckOptions, ExecuteArgs, LoraGraphQLOptions } from './options.js';
+import { CheckReport, LoraExecutionResult, SchemaAssertion } from './results.js';
 export declare class LoraGraphQL {
     #private;
     readonly model: GraphModel;
@@ -374,10 +60,6 @@ export declare class LoraGraphQL {
     /** Use statistics gathered earlier, e.g. by the CLI. */
     useStatistics(stats: Statistics): void;
     get statistics(): Statistics | undefined;
-    /**
-     * The CI gate: @cypher statements plan, the database has what the API
-     * needs, and each operation's statements seek where they should.
-     */
     /**
      * Who may do what: for every type and guarded field, each operation as
      * each kind of caller (anonymous, authenticated, and each role the rules
@@ -390,9 +72,17 @@ export declare class LoraGraphQL {
      * of caller, from the same rules as `accessMatrix()`, plus the most
      * restrictive verdict per caller. Takes a document (source or parsed)
      * or the id of a persisted operation; `operationName` picks one of
-     * several operations.
+     * several operations. A mutation's inputs are read for the
+     * relationship writes they make (a nested connect, disconnect, create,
+     * update or delete), which count towards its root field's verdict.
+     * Pass `variables` for inputs the document takes as variables; a
+     * variable without a value is listed in the field's `unresolved`.
+     */
+    operationAccess(document: string | DocumentNode, operationName?: string, variables?: Readonly<Record<string, unknown>>): OperationAccess;
+    /**
+     * The CI gate: @cypher statements plan, the database has what the API
+     * needs, and each operation's statements seek where they should.
      */
-    operationAccess(document: string | DocumentNode, operationName?: string): OperationAccess;
     check(options?: CheckOptions): Promise<CheckReport>;
     /**
      * Compile a query without running it: one entry per root field, with its

package/dist/model/build/authorization.d.ts

@@ -0,0 +1,31 @@
+import { AuthOperation, Authorization, RelationshipField } from '../types.js';
+export declare function authOps(args: Record<string, unknown> | undefined): Set<AuthOperation> | undefined;
+/**
+ * Field-level rules on a relationship or @cypher field: READ validate rules
+ * only, checked for each row that reads (or filters on) the field.
+ */
+export declare function readOnlyRules(args: Record<string, unknown> | undefined, at: (message: string) => void, relationship?: boolean): Authorization | undefined;
+/**
+ * `@authorization` on a Query or Mutation @cypher field: validate rules
+ * guarding the call, tested before the statement runs. There is no node,
+ * so they test claims (`jwt`) and the caller's node (`viewer`); their
+ * `operations` and `when` do not matter.
+ */
+export declare function rootFieldRules(args: Record<string, unknown> | undefined, at: (message: string) => void): Authorization | undefined;
+export declare function readAuthorization(args: Record<string, unknown> | undefined): Authorization | undefined;
+export declare const PROPERTY_OPS: Set<AuthOperation>;
+/** Keys of a rule that are not claim tests: `node`, `viewer`, … */
+/**
+ * Whether a request without a token could pass the rule: some branch
+ * reads no claim. A claim read without a token denies its branch (and
+ * the whole rule under NOT), so those branches never pass.
+ */
+export declare function passableWithoutClaims(where: unknown): boolean;
+export declare function claimsOnlyViolations(where: unknown, path?: string): string[];
+/** The relationship operations a field's rules cover. */
+export declare function relationshipRuleOperations(f: RelationshipField): Set<AuthOperation>;
+/** A rule over a relationship's source, target and edge. */
+export declare const isRelationshipRule: (rule: {
+    operations: ReadonlySet<AuthOperation>;
+}) => boolean;
+export declare const isRecord: (x: unknown) => x is Record<string, unknown>;

package/dist/model/build/cypher-field.d.ts

@@ -0,0 +1,11 @@
+import { GraphQLDirective, GraphQLField, GraphQLSchema } from 'graphql';
+import { ModelProblem } from '../../errors.js';
+import { CypherField, ModelWarning } from '../types.js';
+export declare function buildCypherField(owner: string, f: GraphQLField<unknown, unknown>, d: (n: string) => GraphQLDirective, problems: ModelProblem[], warnings: ModelWarning[], ctx: {
+    nodeNames: Set<string>;
+    plainNames: Set<string>;
+    schema: GraphQLSchema;
+    root: "Query" | "Mutation" | undefined;
+    /** Whether the @jwt type has a @viewer claim (enables `$viewer`). */
+    viewer: boolean;
+}): CypherField | undefined;

package/dist/model/build/directive-args.d.ts

@@ -0,0 +1,16 @@
+import { ConstDirectiveNode, GraphQLDirective } from 'graphql';
+export declare function directive(def: GraphQLDirective, node: {
+    astNode?: unknown;
+    extensionASTNodes?: unknown;
+}, at: (message: string) => void): Record<string, unknown> | undefined;
+/**
+ * Every use of the directive `name` on `node`: its definition's, then each
+ * extension's, with where it was written (for messages).
+ */
+export declare function directiveNodes(name: string, node: {
+    astNode?: unknown;
+    extensionASTNodes?: unknown;
+}): Array<{
+    node: ConstDirectiveNode;
+    place: string;
+}>;

package/dist/model/build/limits.d.ts

@@ -0,0 +1,18 @@
+import { ModelProblem } from '../../errors.js';
+import { PageLimit } 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;
+export declare function resolveGlobalLimit(options: ModelOptions): PageLimit;
+export declare function resolveLimit(args: Record<string, unknown> | undefined, global: PageLimit, type: string, field: string | undefined, problems: ModelProblem[]): PageLimit;

package/dist/model/build/relationship-field.d.ts

@@ -0,0 +1,11 @@
+import { GraphQLDirective, GraphQLField, GraphQLObjectType } from 'graphql';
+import { ModelProblem } from '../../errors.js';
+import { DeclaredRelationship, NodeType, PageLimit, RelationshipField } from '../types.js';
+/**
+ * An interface field under `@declareRelationship`: every implementation
+ * must declare a relationship field of that name with the same target and
+ * shape (the relationship type and direction may differ). Returns the
+ * problem when one does not.
+ */
+export declare function declareRelationship(iface: string, f: GraphQLField<unknown, unknown>, members: readonly string[], nodes: ReadonlyMap<string, NodeType>): DeclaredRelationship | string;
+export declare function buildRelationshipField(t: GraphQLObjectType, f: GraphQLField<unknown, unknown>, d: (n: string) => GraphQLDirective, problems: ModelProblem[], propsNames: Set<string>, globalLimit: PageLimit): RelationshipField | undefined;

package/dist/model/build/rule-checks.d.ts

@@ -0,0 +1,23 @@
+import { ModelProblem } from '../../errors.js';
+import { AbstractType, NodeType, RelationshipPropertiesType } from '../types.js';
+/** Check an `@authorization` where against the model, at startup. */
+export declare function checkAuthorizationWhere(nodes: ReadonlyMap<string, NodeType>, props: ReadonlyMap<string, RelationshipPropertiesType>, node: NodeType, where: unknown, problems: ModelProblem[], jwtShape?: ReadonlyMap<string, string>, viewerNode?: NodeType): void;
+/**
+ * Check a rule's where. Without `node` (a relationship property's rules)
+ * only claims may be tested: a @relationshipProperties type can sit under
+ * several relationship fields, from either end, so `node` would be
+ * ambiguous.
+ */
+/** The ends a relationship field's rule tests, for its checks. */
+export interface RuleEnds {
+    source: NodeType;
+    target: NodeType;
+    edge: RelationshipPropertiesType | undefined;
+}
+export declare function checkRuleWhere(nodes: ReadonlyMap<string, NodeType>, props: ReadonlyMap<string, RelationshipPropertiesType>, node: NodeType | undefined, type: string, field: string | undefined, where: unknown, problems: ModelProblem[], jwtShape?: ReadonlyMap<string, string>, viewerNode?: NodeType, ends?: RuleEnds, nodeless?: string): void;
+export declare function checkNodeWhere(nodes: ReadonlyMap<string, NodeType>, props: ReadonlyMap<string, RelationshipPropertiesType>, node: NodeType, where: unknown, path: string, at: (message: string) => void): void;
+/**
+ * Interfaces and unions of a model being built, by its node map: the rule
+ * checks below receive the node map only.
+ */
+export declare const abstractsOf: WeakMap<ReadonlyMap<string, NodeType>, ReadonlyMap<string, AbstractType>>;

package/dist/model/build/rule-references.d.ts

@@ -0,0 +1,28 @@
+import { NodeType, RelationshipPropertiesType } from '../types.js';
+/**
+ * Claim names referenced anywhere in a value: as "$jwt.name…" strings and
+ * as ${jwt.name…} placeholders.
+ */
+export declare function claimRefs(value: unknown): string[];
+/**
+ * Malformed claim and context references in a rule's strings: a whole
+ * string "$jwt.path" names a path and nothing else; any `${` starts a
+ * `${jwt.path}` or `${context.path}` placeholder.
+ */
+/** `${viewer.field}` placeholders need @viewer, a scalar field, a string operand. */
+export declare function viewerRefProblems(value: unknown, viewerNode: NodeType | undefined, inList?: boolean): string[];
+/** What a rule's `${node.…}`, `${source.…}`, `${target.…}`, `${edge.…}` may read. */
+export interface RuleReferences {
+    node?: NodeType;
+    source?: NodeType;
+    target?: NodeType;
+    edge?: RelationshipPropertiesType | undefined;
+}
+/**
+ * `${node.path}`-style placeholders: the source must be available where
+ * the string stands (`node` in a type's rules, `source` / `target` /
+ * `edge` in a relationship field's), the path must reach a scalar through
+ * single relationships to node types, and it stands for one value.
+ */
+export declare function ruleReferenceProblems(value: unknown, refs: RuleReferences, nodes: ReadonlyMap<string, NodeType>, inList?: boolean): string[];
+export declare function ruleStringProblems(value: unknown): string[];

package/dist/model/build/scalar-field.d.ts

@@ -0,0 +1,7 @@
+import { GraphQLDirective, GraphQLField, GraphQLObjectType } from 'graphql';
+import { ModelProblem } from '../../errors.js';
+import { ScalarField, ScalarType } from '../types.js';
+export declare function buildScalarField(t: GraphQLObjectType, f: GraphQLField<unknown, unknown>, d: (n: string) => GraphQLDirective, problems: ModelProblem[], opts: {
+    allowKey: boolean;
+}): ScalarField | undefined;
+export declare function defaultMatches(type: ScalarType, list: boolean, value: unknown): boolean;

package/dist/model/build/search.d.ts

@@ -0,0 +1,4 @@
+import { ModelProblem } from '../../errors.js';
+import { SearchIndex, ScalarField } from '../types.js';
+export declare const vectorQueryNames: WeakMap<ScalarField, string>;
+export declare function readSearch(typeName: string, label: string, defaultName: string, plural: string | undefined, scalars: ScalarField[], fulltext: Record<string, unknown> | undefined, problems: ModelProblem[]): SearchIndex[];

package/dist/model/build/shapes.d.ts

@@ -0,0 +1,18 @@
+import { GraphQLNamedType, GraphQLInputType, GraphQLOutputType, GraphQLSchema } from 'graphql';
+import { TypeShape, ScalarType } from '../types.js';
+export declare const BUILTIN_SCALARS: Record<string, ScalarType>;
+export declare function unwrap(type: GraphQLOutputType): {
+    required: boolean;
+    list: boolean;
+    itemRequired: boolean;
+    depth: number;
+};
+export declare function isScalarLike(name: string, schema: GraphQLSchema): boolean;
+/** 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;
+export declare function shapeOf(shape: ReturnType<typeof unwrap>): Omit<TypeShape, "named">;
+export declare function unwrapInput(type: GraphQLInputType): Omit<TypeShape, "named">;
+export declare function upperFirst(s: string): string;
+export declare function snakeCase(s: string): string;

package/dist/model/build/unique-together.d.ts

@@ -0,0 +1,5 @@
+import { GraphQLDirective, GraphQLObjectType } from 'graphql';
+import { ModelProblem } from '../../errors.js';
+import { NodeType, RelationshipPropertiesType, UniqueTogether } from '../types.js';
+/** Every `@uniqueTogether` of a node type (repeatable), checked. */
+export declare function readUniqueTogether(t: GraphQLObjectType, node: NodeType, nodes: ReadonlyMap<string, NodeType>, props: ReadonlyMap<string, RelationshipPropertiesType>, d: (name: string) => GraphQLDirective, problems: ModelProblem[]): UniqueTogether[];

package/dist/model/build.d.ts

@@ -1,25 +1,8 @@
-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;
+import { DocumentNode } from 'graphql';
+import { GraphModel } from './types.js';
+import { ModelOptions } from './build/limits.js';
 /**
  * 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;