lambdaorm-cli/infrastructure/orm/adapters/lib.d.ts

The lambdaorm command line interface

import { MetadataModel, MetadataParameter, MetadataConstraint, Metadata, QueryOptions, QueryPlan, IOrm, DomainSchema, Entity, EntityMapping, Enum, Mapping, Schema, Stage, SchemaData, SchemaState, ExecuteResult } from 'lambdaorm';
import { OrmService, CliSchemaService, CliStageService } from '../../../application';
export declare class LibSchemaService implements CliSchemaService {
    private readonly schemaState;
    constructor(schemaState: SchemaState);
    introspect(data: any, name: string): Promise<void>;
    sources(): Promise<{
        name: string;
        dialect: string;
    }[]>;
    source(source: string): Promise<{
        name: string;
        dialect: string;
    }>;
    version(): Promise<{
        version: string | undefined;
    }>;
    schema(): Promise<Schema>;
    originalSchema(): Promise<Schema>;
    domain(): Promise<DomainSchema>;
    entities(): Promise<Entity[]>;
    entity(entity: string): Promise<Entity | undefined>;
    enums(): Promise<Enum[]>;
    enum(_enum: string): Promise<Enum | undefined>;
    mappings(): Promise<Mapping[]>;
    mapping(mapping: string): Promise<Mapping | undefined>;
    entityMapping(mapping: string, entity: string): Promise<EntityMapping | undefined>;
    stages(): Promise<Stage[]>;
    stage(stage: string): Promise<Stage | undefined>;
    views(): Promise<string[]>;
}
export declare class LibStageService implements CliStageService {
    private readonly orm;
    private readonly workspace;
    constructor(orm: IOrm, workspace: string);
    exists(stage: string): Promise<boolean>;
    fetch(stage: string): Promise<Mapping[]>;
    pull(stage: string): Promise<ExecuteResult[]>;
    introspect(data: any, name: string, stage?: string): Promise<ExecuteResult[]>;
    incorporate(data: any, name: string, stage?: string): Promise<ExecuteResult[]>;
    export(stage: string, force: boolean): Promise<SchemaData>;
    import(stage: string, schemaData: any): Promise<void>;
    drop(stage: string, sentence: boolean, force: boolean): Promise<ExecuteResult[] | any[]>;
    push(stage: string, sentence: boolean, force: boolean): Promise<ExecuteResult[] | any[]>;
}
export declare class LibOrmService implements OrmService {
    private readonly workspace;
    private _schema?;
    private _stage?;
    private readonly orm;
    constructor(workspace: string);
    init(): Promise<any>;
    get schema(): CliSchemaService;
    get stage(): CliStageService;
    getStageName(stage?: string): Promise<string>;
    end(): Promise<void>;
    model(query: string): Promise<MetadataModel[]>;
    parameters(query: string): Promise<MetadataParameter[]>;
    constraints(query: string): Promise<MetadataConstraint>;
    metadata(query: string): Promise<Metadata>;
    plan(query: string, options?: QueryOptions | undefined): Promise<QueryPlan>;
    execute(query: string, data?: any, options?: QueryOptions | undefined): Promise<any>;
}