@goatlab/fluent 0.6.22 → 0.6.30

package/dist/Fluent.js

@@ -1,45 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Fluent = void 0;
-const typed_path_1 = require("typed-path");
 const js_utils_1 = require("@goatlab/js-utils");
 const generatorDatasource_1 = require("./generatorDatasource");
-if (typeof window !== 'undefined' && window && !window._FLUENT_) {
-    window._FLUENT_ = {
-        models: {}
-    };
-}
-if (global && !global._FLUENT_) {
-    global._FLUENT_ = {
-        models: {}
-    };
-}
 class Fluent {
-    static registerModel(name) {
-        if (!name || name === 'baseModel') {
-            return;
-        }
-        if (typeof window !== 'undefined') {
-            window._FLUENT_.models[name] = true;
-            return;
-        }
-        global._FLUENT_.models[name] = true;
-    }
-    static model(name) {
-        this.registerModel(name);
-        return (0, typed_path_1.typedPath)();
-    }
     static collect(data) {
         return new js_utils_1.Collection(data);
     }
-    static getConfig() {
-        if (typeof window !== 'undefined' && window) {
-            return window._FLUENT_;
-        }
-        if (typeof global !== 'undefined' && global) {
-            return global._FLUENT_;
-        }
-    }
     static async initialize(dataSources, Entities) {
         generatorDatasource_1.modelGeneratorDataSource.setOptions({ entities: Entities });
         if (!generatorDatasource_1.modelGeneratorDataSource.isInitialized) {

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, DaoOutput, 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, DaoOutput<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<DaoOutput<InputDTO, OutputDTO>[]>;
-    getPaginated(): Promise<PaginatedData<DaoOutput<InputDTO, OutputDTO>>>;
-    all(): Promise<DaoOutput<InputDTO, OutputDTO>[]>;
-    find(filter?: Filter): Promise<DaoOutput<InputDTO, OutputDTO>[]>;
-    paginate(paginator: Paginator): Promise<PaginatedData<DaoOutput<InputDTO, OutputDTO>>>;
+    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>;
-    insert(data: InputDTO): Promise<DaoOutput<InputDTO, OutputDTO>>;
-    insertMany(data: InputDTO[]): Promise<DaoOutput<InputDTO, OutputDTO>[]>;
-    updateById(id: string, data: InputDTO): Promise<DaoOutput<InputDTO, OutputDTO>>;
-    replaceById(id: string, data: InputDTO): Promise<DaoOutput<InputDTO, OutputDTO>>;
-    clear({ sure }: Sure): Promise<boolean>;
-    deleteById(id: string): Promise<string>;
-    findById(id: string): Promise<DaoOutput<InputDTO, OutputDTO>>;
-    findByIds(ids: string[]): Promise<DaoOutput<InputDTO, OutputDTO>[]>;
-    private getPage;
-    private getPaginatorLimit;
-    private getPopulate;
-    private getGeneratedQuery;
-    private getFilters;
-    getMongoFilters(filters: any): any;
+    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(): 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;
 }