alinea/dist/core/db/EntryResolver.d.ts

Headless git-based CMS

import type { Type } from 'alinea';
import type { Config } from 'alinea/core/Config';
import type { Entry } from 'alinea/core/Entry';
import type { Expr } from 'alinea/core/Expr';
import { Field } from 'alinea/core/Field';
import { type AnyQueryResult, type Edge, type EdgeQuery, type GraphQuery, type Projection, type Status } from 'alinea/core/Graph';
import { type HasExpr } from 'alinea/core/Internal';
import type { Resolver } from 'alinea/core/Resolver';
import { type EntryCondition, type EntryFilter, type EntryGraph, type EntryIndex } from './EntryIndex.js';
import { LinkResolver } from './LinkResolver.js';
type Interim = any;
export interface PostContext {
    linkResolver: LinkResolver;
}
export declare class EntryResolver implements Resolver {
    #private;
    index: EntryIndex;
    constructor(config: Config, index: EntryIndex);
    call(ctx: ResolveContext, entry: Entry, internal: {
        method: string;
        args: Array<Expr>;
    }): unknown;
    field(entry: Entry, field: Expr): unknown;
    expr(ctx: ResolveContext, entry: Entry, expr: Expr): unknown;
    projectTypes(types: Array<Type>): Array<[string, Expr]>;
    projection(query: GraphQuery<Projection>): Projection;
    sourceFilter(ctx: ResolveContext, entry: Entry, query: EdgeQuery): EntryCondition;
    selectProjection(ctx: ResolveContext, entry: Entry, value: Projection): unknown;
    select(ctx: ResolveContext, entry: Entry | null, query: GraphQuery<Projection>): unknown;
    condition(ctx: ResolveContext, query: EdgeQuery): EntryFilter;
    isSingleResult(query: GraphQuery & Partial<Edge>): boolean;
    query(ctx: ResolveContext, query: GraphQuery<Projection>, preFilter?: EntryCondition): {
        entries: Entry<Record<string, unknown>>[];
        getUnprocessed: () => unknown;
        getProcessed: () => Promise<any>;
    };
    postField(ctx: PostContext, interim: Interim, field: Field): Promise<void>;
    postExpr(ctx: PostContext, interim: Interim, expr: HasExpr): Promise<void>;
    postRow(ctx: PostContext, interim: Interim, query: GraphQuery<Projection>): Promise<void>;
    post(ctx: PostContext, interim: Interim, input: EdgeQuery<Projection>): Promise<void>;
    resolve<Query extends GraphQuery>(query: Query): Promise<AnyQueryResult<Query>>;
}
export interface ResolveContext {
    status: Status;
    locale?: string | null;
    graph: EntryGraph;
    searchTerms?: string;
}
export declare function statusChecker(status: Status): Check;
interface Check {
    (input: Entry): boolean;
}
export {};