alinea/dist/backend/resolver/EntryResolver.d.ts

[](https://npmjs.org/package/alinea) [](https://packagephobia.com/result?p=alinea)

import { Connection, PreviewUpdate, ResolveDefaults, Schema } from 'alinea/core';
import { EntryRow, EntryTable } from 'alinea/core/EntryRow';
import type * as pages from 'alinea/core/pages';
import { Realm } from 'alinea/core/pages/Realm';
import { Expr, ExprData, OrderBy, QueryData, Select, Table } from 'rado';
import { Database } from '../Database.js';
import { LinkResolver } from './LinkResolver.js';
import { ResolveContext } from './ResolveContext.js';
type Interim = any;
export interface PostContext {
    linkResolver: LinkResolver;
}
export declare class EntryResolver {
    db: Database;
    schema: Schema;
    parsePreview?: ((preview: PreviewUpdate) => Promise<EntryRow | undefined>) | undefined;
    defaults?: ResolveDefaults | undefined;
    targets: Schema.Targets;
    constructor(db: Database, schema: Schema, parsePreview?: ((preview: PreviewUpdate) => Promise<EntryRow | undefined>) | undefined, defaults?: ResolveDefaults | undefined);
    fieldOf(ctx: ResolveContext, target: pages.TargetData, field: string): ExprData;
    pageFields(ctx: ResolveContext): Array<[string, ExprData]>;
    selectFieldsOf(ctx: ResolveContext, target: pages.TargetData): Array<[string, ExprData]>;
    exprUnOp(ctx: ResolveContext, { op, expr }: pages.ExprData.UnOp): ExprData;
    exprBinOp(ctx: ResolveContext, { op, a, b }: pages.ExprData.BinOp): ExprData;
    exprField(ctx: ResolveContext, { target, field }: pages.ExprData.Field): ExprData;
    exprAccess(ctx: ResolveContext, { expr, field }: pages.ExprData.Access): ExprData;
    exprValue(ctx: ResolveContext, { value }: pages.ExprData.Value): ExprData;
    exprRecord(ctx: ResolveContext, { fields }: pages.ExprData.Record): ExprData;
    exprCase(ctx: ResolveContext, { expr, cases, defaultCase }: pages.ExprData.Case): ExprData;
    expr(ctx: ResolveContext, expr: pages.ExprData): ExprData;
    selectRecord(ctx: ResolveContext, { fields }: pages.Selection.Record): ExprData;
    selectRow(ctx: ResolveContext, { target }: pages.Selection.Row): ExprData;
    selectCursor(ctx: ResolveContext, selection: pages.Selection.Cursor): ExprData;
    selectExpr(ctx: ResolveContext, { expr, fromParent }: pages.Selection.Expr): ExprData;
    selectCount(): ExprData;
    selectAll(ctx: ResolveContext, target: pages.TargetData): ExprData;
    select(ctx: ResolveContext, selection: pages.Selection): ExprData;
    queryRecord(ctx: ResolveContext, selection: pages.Selection.Record): QueryData.Select;
    querySource(ctx: ResolveContext, source: pages.CursorSource | undefined, hasSearch: boolean): Select<Table.Select<EntryTable>>;
    orderBy(ctx: ResolveContext, orderBy: Array<pages.OrderBy>): Array<OrderBy>;
    conditionLocale(Table: Table<EntryTable>, locale?: string): Expr<boolean>;
    conditionRealm(Table: Table<EntryTable>, realm: Realm): Expr<boolean>;
    conditionLocation(Table: Table<EntryTable>, location: Array<string>): Expr<boolean>;
    conditionSearch(Table: Table<EntryTable>, searchTerms?: Array<string>): Expr<boolean>;
    queryCursor(ctx: ResolveContext, { cursor }: pages.Selection.Cursor): QueryData.Select;
    query(ctx: ResolveContext, selection: pages.Selection): QueryData.Select;
    postRow(ctx: PostContext, interim: Interim, { target }: pages.Selection.Row): Promise<void>;
    postCursor(ctx: PostContext, interim: Interim, { cursor }: pages.Selection.Cursor): Promise<void>;
    postField(ctx: PostContext, interim: Interim, { target, field }: pages.ExprData.Field): Promise<void>;
    postExpr(ctx: PostContext, interim: Interim, { expr }: pages.Selection.Expr): Promise<void>;
    postFieldsOf(ctx: PostContext, interim: Interim, target: pages.TargetData): Promise<void>;
    postRecord(ctx: PostContext, interim: Interim, { fields }: pages.Selection.Record): Promise<void>;
    post(ctx: PostContext, interim: Interim, selection: pages.Selection): Promise<void>;
    resolve: <T>({ selection, location, locale, realm, preview }: Connection.ResolveParams) => Promise<T>;
}
export {};