@goatlab/fluent 0.6.24 → 0.6.30

package/dist/FluentEntity.d.ts

@@ -0,0 +1,7 @@
+export declare class FluentEntity {
+    type?: string;
+    roles?: string[];
+    created?: Date;
+    updated?: Date;
+    deleted?: Date;
+}

package/dist/FluentEntity.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FluentEntity = void 0;
+const tslib_1 = require("tslib");
+const decorators_1 = require("./decorators");
+class FluentEntity {
+}
+tslib_1.__decorate([
+    decorators_1.f.property({ required: false }),
+    tslib_1.__metadata("design:type", String)
+], FluentEntity.prototype, "type", void 0);
+tslib_1.__decorate([
+    decorators_1.f.stringArray(String, { required: false }),
+    tslib_1.__metadata("design:type", Array)
+], FluentEntity.prototype, "roles", void 0);
+tslib_1.__decorate([
+    decorators_1.f.created(),
+    tslib_1.__metadata("design:type", Date)
+], FluentEntity.prototype, "created", void 0);
+tslib_1.__decorate([
+    decorators_1.f.updated(),
+    tslib_1.__metadata("design:type", Date)
+], FluentEntity.prototype, "updated", void 0);
+tslib_1.__decorate([
+    decorators_1.f.deleted(),
+    tslib_1.__metadata("design:type", Date)
+], FluentEntity.prototype, "deleted", void 0);
+exports.FluentEntity = FluentEntity;

package/dist/TypeOrmConnector/TypeOrmConnector.d.ts

@@ -1,36 +1,43 @@
-import { Repository } from 'typeorm';
+import { FindByIdFilter, LoadedResult, QueryOutput, SingleQueryOutput } from './../types';
+import { FindManyOptions, Repository, MongoRepository } from 'typeorm';
 import { BaseConnector, FluentConnectorInterface } from '../BaseConnector';
-import type { Filter, BaseDataElement, PaginatedData, Paginator, Sure } from '../types';
+import type { AnyObject, FluentQuery } from '../types';
 import { DataSource } from 'typeorm';
-export declare const getRelations: (typeOrmRepo: any) => {
+import { z } from 'zod';
+export declare const getRelationsFromModelGenerator: (typeOrmRepo: Repository<any>) => {
     relations: {};
 };
-export declare class TypeOrmConnector<ModelDTO = BaseDataElement, InputDTO = ModelDTO, OutputDTO = InputDTO> extends BaseConnector<ModelDTO, InputDTO, OutputDTO> implements FluentConnectorInterface<InputDTO, OutputDTO> {
+export interface TypeOrmConnectorParams<Input, Output> {
+    entity: any;
+    dataSource: DataSource;
+    inputSchema: z.ZodType<Input>;
+    outputSchema?: z.ZodType<Output>;
+}
+export declare class TypeOrmConnector<ModelDTO = AnyObject, InputDTO = ModelDTO, OutputDTO = InputDTO> extends BaseConnector<ModelDTO, InputDTO, OutputDTO> implements FluentConnectorInterface<ModelDTO, InputDTO, OutputDTO> {
     private readonly repository;
     private readonly dataSource;
-    constructor(entity: any, dataSource: DataSource, relationQuery?: any);
-    get(): Promise<OutputDTO[]>;
-    getPaginated(): Promise<PaginatedData<OutputDTO>>;
-    all(): Promise<OutputDTO[]>;
-    find(filter?: Filter): Promise<OutputDTO[]>;
-    paginate(paginator: Paginator): Promise<PaginatedData<OutputDTO>>;
-    raw(): Repository<ModelDTO>;
+    private readonly inputSchema;
+    private readonly outputSchema;
+    private readonly entity;
+    constructor({ entity, dataSource, inputSchema, outputSchema }: TypeOrmConnectorParams<InputDTO, OutputDTO>);
     insert(data: InputDTO): Promise<OutputDTO>;
     insertMany(data: InputDTO[]): Promise<OutputDTO[]>;
+    raw(): Repository<ModelDTO>;
+    mongoRaw(): MongoRepository<ModelDTO>;
+    findMany<T extends FluentQuery<ModelDTO>>(query?: T): Promise<QueryOutput<T, ModelDTO, OutputDTO>>;
+    private getMongoSelect;
+    private getMongoLookup;
+    private customMongoRelatedSearch;
+    private generateTypeOrmQuery;
+    protected getTypeOrmWhere(where?: FluentQuery<ModelDTO>['where']): FindManyOptions['where'];
+    protected getTypeOrmMongoWhere(where?: FluentQuery<ModelDTO>['where']): FindManyOptions['where'];
     updateById(id: string, data: InputDTO): Promise<OutputDTO>;
     replaceById(id: string, data: InputDTO): Promise<OutputDTO>;
-    clear({ sure }: Sure): Promise<boolean>;
-    deleteById(id: string): Promise<string>;
-    findById(id: string): Promise<OutputDTO>;
-    findByIds(ids: string[]): Promise<OutputDTO[]>;
-    private getPage;
-    private getPaginatorLimit;
-    private getPopulate;
-    private getGeneratedQuery;
-    private getFilters;
-    getMongoFilters(filters: any): any;
+    clear(): Promise<boolean>;
+    loadFirst(query?: FluentQuery<ModelDTO>): TypeOrmConnector<ModelDTO, InputDTO, OutputDTO>;
+    loadById(id: string): LoadedResult<this>;
+    requireById(id: string, q?: FindByIdFilter<ModelDTO>): Promise<SingleQueryOutput<FindByIdFilter<ModelDTO>, ModelDTO, OutputDTO>>;
+    protected clone(): any;
+    findByIds<T extends FindByIdFilter<ModelDTO>>(ids: string[], q?: T): Promise<QueryOutput<T, ModelDTO, OutputDTO>>;
     private getOrderBy;
-    private getLimit;
-    private getSkip;
-    private getSelect;
 }