@goatlab/fluent/dist/TypeOrmConnector/TypeOrmConnector.d.ts

Readable query Interface & API generator for TS and Node

/**
 * Inspiration: https://github.com/laravel/framework/blob/9.x/src/Illuminate/Database/Eloquent/Model.php
 */
import { DataSource, MongoRepository, ObjectLiteral, Repository } from 'typeorm';
import { z } from 'zod';
import { BaseConnector } from '../BaseConnector';
import { FluentConnectorInterface } from '../FluentConnectorInterface';
import { LoadedResult, QueryOutput } from './../types';
import type { AnyObject, FluentQuery } from '../types';
export interface TypeOrmConnectorParams<Input, Output> {
    entity: any;
    dataSource: DataSource | (() => DataSource);
    inputSchema: z.ZodType<Input>;
    outputSchema?: z.ZodType<Output>;
}
export declare class TypeOrmConnector<ModelDTO extends ObjectLiteral & {
    id?: string;
} = {
    id?: string;
} & AnyObject, InputDTO = ModelDTO, OutputDTO = InputDTO> extends BaseConnector<ModelDTO, InputDTO, OutputDTO> implements FluentConnectorInterface<ModelDTO, InputDTO, OutputDTO> {
    private repository;
    private readonly dataSourceOrGetter;
    private cachedDataSource;
    private get dataSource();
    private readonly inputSchema;
    private readonly outputSchema;
    private readonly entity;
    constructor({ entity, dataSource, inputSchema, outputSchema }: TypeOrmConnectorParams<InputDTO, OutputDTO>);
    initDB(): number;
    /**
     * Insert the data object into the database.
     * @param data
     */
    insert(data: InputDTO): Promise<OutputDTO>;
    insertMany(data: InputDTO[]): Promise<OutputDTO[]>;
    findMany<T extends FluentQuery<ModelDTO>>(query?: T): Promise<QueryOutput<T, ModelDTO>[]>;
    /**
     * PATCH operation
     * @param data
     */
    updateById(id: string, data: InputDTO): Promise<OutputDTO>;
    /**
     *
     * PUT operation. All fields not included in the data
     *  param will be set to null
     *
     * @param id
     * @param data
     */
    replaceById(id: string, data: InputDTO): Promise<OutputDTO>;
    /**
     *
     * @param id
     * @returns
     */
    deleteById(id: string): Promise<string>;
    /**
     *
     * @returns
     */
    clear(): Promise<boolean>;
    /**
     *
     * @param query
     * @returns
     */
    loadFirst(query?: FluentQuery<ModelDTO>): LoadedResult<this>;
    /**
     *
     * @param id
     * @returns
     */
    loadById(id: string): LoadedResult<this>;
    /**
     *
     * Returns the TypeOrm Repository, you can use it
     * form more complex queries and to get
     * the TypeOrm query builder
     *
     * @param query
     */
    raw(): Repository<ModelDTO>;
    /**
     *
     * Returns the TypeOrm Repository, you can use it
     * form more complex queries and to get
     * the TypeOrm query builder
     *
     * @param query
     */
    mongoRaw(): MongoRepository<ModelDTO>;
    /**
     * Creates a Clone of the current instance of the class
     * @returns
     */
    protected clone(): any;
    /**
     * Apply select filter to remove fields explicitly set to false
     * @param results The query results
     * @param select The select configuration
     * @returns Filtered results
     */
    private applySelectFilter;
    private applyInclusiveSelection;
    private applyExclusiveSelection;
    private copyNestedField;
    private deleteNestedField;
    /**
     *
     * @param query
     * @returns
     */
    private generateTypeOrmQuery;
    /**
     *
     * @param query
     * @returns
     */
    private customTypeOrmRelatedFind;
    private getTypeOrmQueryBuilderSelect;
    private getTypeOrmQueryBuilderSubqueries;
    /**
     *
     * @param query
     * @returns
     */
    private customMongoRelatedFind;
}