taon 0.0.0 → 18.0.12

package/client/lib/realtime/realtime-strategy/realtime-strategy-ipc-models/realtime-strategy-ipc-renderer-wrapper.d.ts

@@ -0,0 +1,11 @@
+// @ts-nocheck
+import { IpcRendererNamespace } from './realtime-strategy-ipc-renderer-namespace';
+export declare class IpcRendererWrapper {
+    contextName: string;
+    private namespaces;
+    private connected;
+    constructor(contextName: string);
+    of(namespace: string): IpcRendererNamespace;
+    on(event: string, callback: (event: any, ...args: any[]) => void): void;
+    emit(event: string, ...args: any[]): void;
+}

package/client/lib/realtime/realtime-strategy/realtime-strategy-ipc-models/realtime-strategy-ipc.models.d.ts

@@ -0,0 +1,14 @@
+// @ts-nocheck
+import { IpcMainNamespace } from './realtime-strategy-ipc-main-namespace';
+export interface RendererEventListeners {
+    [event: string]: Array<(event: any, ...args: any[]) => void>;
+}
+export interface EventListeners {
+    [event: string]: Array<(event: Electron.IpcMainEvent, ...args: any[]) => void>;
+}
+export interface Rooms {
+    [room: string]: Set<Electron.WebContents>;
+}
+export interface Namespaces {
+    [namespace: string]: IpcMainNamespace;
+}

package/client/lib/realtime/realtime-strategy/realtime-strategy-ipc.d.ts

@@ -0,0 +1,23 @@
+// @ts-nocheck
+import { Server } from 'socket.io';
+import { EndpointContext } from '../../endpoint-context';
+import { RealtimeStrategy } from './realtime-strategy';
+import type { io } from 'socket.io-client';
+/**
+ * Purpose:
+ * - backend-browser communication between 2 processes in electron mode
+ */
+export declare class RealtimeStrategyIpc extends RealtimeStrategy {
+    protected ctx: EndpointContext;
+    toString(): string;
+    establishConnection(): void;
+    constructor(ctx: EndpointContext);
+    contextsServers: {
+        [contextName: string]: Server;
+    };
+    contextsIO: {
+        [contextName: string]: typeof io;
+    };
+    get io(): any;
+    get Server(): any;
+}

package/client/lib/realtime/realtime-strategy/realtime-strategy-mock-models/index.d.ts

@@ -0,0 +1,3 @@
+// @ts-nocheck
+export * from './realtime-strategy-mock-server';
+export * from './realtime-strategy-mock-client';

package/client/lib/realtime/realtime-strategy/realtime-strategy-mock-models/realtime-strategy-mock-client.d.ts

@@ -0,0 +1,17 @@
+// @ts-nocheck
+import { MockServer } from "./realtime-strategy-mock-server";
+import { MockSocket } from "./realtime-strategy-mock-socket";
+declare class MockClientSocket {
+    private serverSocket;
+    contextName: string;
+    private listeners;
+    constructor(serverSocket: MockSocket, contextName: string);
+    on(event: string, callback: (data?: any) => void): void;
+    off(event: string, callback?: (data?: any) => void): void;
+    emit(event: string, data?: any): void;
+    disconnect(): void;
+    join(room: string): void;
+    leave(room: string): void;
+}
+export declare function mockIo(server: MockServer): (namespace?: string) => MockClientSocket;
+export {};

package/client/lib/realtime/realtime-strategy/realtime-strategy-mock-models/realtime-strategy-mock-namespaces.d.ts

@@ -0,0 +1,18 @@
+// @ts-nocheck
+import { MockSocket } from "./realtime-strategy-mock-socket";
+export declare class MockNamespace {
+    name: string;
+    contextName: string;
+    private rooms;
+    private sockets;
+    constructor(name: string, contextName: string);
+    on(event: string, callback: (socket: MockSocket) => void): void;
+    emit(event: string, data?: any): void;
+    to(room: string): {
+        emit: (event: string, data?: any) => void;
+    };
+    joinRoom(socket: MockSocket, room: string): void;
+    leaveRoom(socket: MockSocket, room: string): void;
+    addSocket(socket: MockSocket): void;
+    removeSocket(socket: MockSocket): void;
+}

package/client/lib/realtime/realtime-strategy/realtime-strategy-mock-models/realtime-strategy-mock-server.d.ts

@@ -0,0 +1,12 @@
+// @ts-nocheck
+import { MockNamespace } from "./realtime-strategy-mock-namespaces";
+import { MockSocket } from "./realtime-strategy-mock-socket";
+export declare class MockServer {
+    contextName: string;
+    private namespaces;
+    constructor(contextName: string);
+    of(namespace: string): MockNamespace;
+    on(event: string, callback: (socket: MockSocket) => void): void;
+    emit(event: string, data?: any): void;
+    connect(id: string, namespace?: string): MockSocket;
+}

package/client/lib/realtime/realtime-strategy/realtime-strategy-mock-models/realtime-strategy-mock-socket.d.ts

@@ -0,0 +1,14 @@
+// @ts-nocheck
+import { MockNamespace } from "./realtime-strategy-mock-namespaces";
+export declare class MockSocket {
+    id: string;
+    private namespace;
+    private listeners;
+    constructor(id: string, namespace: MockNamespace);
+    on(event: string, callback: (data?: any) => void): void;
+    off(event: string, callback?: (data?: any) => void): void;
+    emit(event: string, data?: any): void;
+    join(room: string): void;
+    leave(room: string): void;
+    disconnect(): void;
+}

package/client/lib/realtime/realtime-strategy/realtime-strategy-mock-models/realtime-strategy-mock.models.d.ts

@@ -0,0 +1,12 @@
+// @ts-nocheck
+import { MockNamespace } from "./realtime-strategy-mock-namespaces";
+import { MockSocket } from "./realtime-strategy-mock-socket";
+export interface EventListeners {
+    [event: string]: Array<(data?: any) => void>;
+}
+export interface Rooms {
+    [room: string]: Set<MockSocket>;
+}
+export interface Namespaces {
+    [namespace: string]: MockNamespace;
+}

package/client/lib/realtime/realtime-strategy/realtime-strategy-mock.d.ts

@@ -0,0 +1,15 @@
+// @ts-nocheck
+import { EndpointContext } from '../../endpoint-context';
+import { RealtimeStrategy } from './realtime-strategy';
+/**
+ * Purpose:
+ * - browser-browser communication mock (in websql mode)
+ */
+export declare class RealtimeStrategyMock extends RealtimeStrategy {
+    protected ctx: EndpointContext;
+    toString(): string;
+    constructor(ctx: EndpointContext);
+    get Server(): any;
+    get io(): any;
+    establishConnection(): void;
+}

package/client/lib/realtime/realtime-strategy/realtime-strategy-socket-io.d.ts

@@ -0,0 +1,17 @@
+// @ts-nocheck
+import { EndpointContext } from '../../endpoint-context';
+import { RealtimeStrategy } from './realtime-strategy';
+import { io } from 'socket.io-client';
+/**
+ * Purpose:
+ * - backend-browser communication
+ * - backend-backend communication
+ */
+export declare class RealtimeStrategySocketIO extends RealtimeStrategy {
+    protected ctx: EndpointContext;
+    toString(): string;
+    constructor(ctx: EndpointContext);
+    get Server(): any;
+    get io(): typeof io;
+    establishConnection(): void;
+}

package/client/lib/realtime/realtime-strategy/realtime-strategy.d.ts

@@ -0,0 +1,13 @@
+// @ts-nocheck
+import { EndpointContext } from '../../endpoint-context';
+import type { Server } from 'socket.io';
+import type { io } from 'socket.io-client';
+export declare abstract class RealtimeStrategy {
+    protected ctx: EndpointContext;
+    constructor(ctx: EndpointContext);
+    private testTypes;
+    abstract establishConnection(): void;
+    abstract readonly io: typeof io;
+    abstract readonly Server: typeof Server;
+    abstract toString(): string;
+}

package/client/lib/realtime/realtime-subs-manager.d.ts

@@ -0,0 +1,15 @@
+// @ts-nocheck
+import { Subscriber } from 'rxjs';
+import { Socket as SocketClient } from 'socket.io-client';
+import { DefaultEventsMap } from 'socket.io/dist/typed-events';
+import { RealtimeModels } from './realtime.models';
+export declare class RealtimeSubsManager {
+    private options;
+    private isListening;
+    private observers;
+    constructor(options: RealtimeModels.SubsManagerOpt);
+    startListenIfNotStarted(realtime: SocketClient<DefaultEventsMap, DefaultEventsMap>): void;
+    add(observer: Subscriber<any>): void;
+    remove(observer: Subscriber<any>): void;
+    private update;
+}

package/client/lib/realtime/realtime.models.d.ts

@@ -0,0 +1,14 @@
+// @ts-nocheck
+import type { RealtimeCore } from './realtime-core';
+export declare namespace RealtimeModels {
+    type SubsManagerOpt = {
+        core: RealtimeCore;
+        customEvent: string;
+        roomName: string;
+        property: string;
+    };
+    type ChangeOption = {
+        property?: string;
+        customEvent?: string;
+    };
+}

package/client/lib/storage.d.ts

@@ -0,0 +1,2 @@
+// @ts-nocheck
+export declare const globalPublicStorage: typeof globalThis;

package/client/lib/symbols.d.ts

@@ -0,0 +1,73 @@
+// @ts-nocheck
+export declare namespace Symbols {
+    const ctxInClassOrClassObj: unique symbol;
+    const classNameStaticProperty: string;
+    const fullClassNameStaticProperty: string;
+    const orignalClass: string;
+    const orignalClassClonesObj: string;
+    const classMethodsNames: string;
+    const REALTIME: {
+        NAMESPACE: (contextName: string) => string;
+        TABLE_CHANGE(contextName: string, tableName: string): string;
+        /**
+         * for backendSocket.in(ROOM_NAME).emit(EVENT)
+         *
+         * Room names are uniqe..
+         * here I am limiting number of event for clients.
+         */
+        ROOM_NAME: {
+            CUSTOM(contextName: string, customEvent: string): string;
+            /**
+             * @LAST TODO
+             */
+            SUBSCRIBER_EVENT(contextName: string, className: string, propertyName: string): string;
+            UPDATE_ENTITY(contextName: string, className: string, entityId: number | string): string;
+            UPDATE_ENTITY_PROPERTY(contextName: string, className: string, property: string, entityId: number | string): string;
+            SUBSCRIBE: {
+                CUSTOM: (contextName: string) => string;
+                ENTITY_UPDATE_EVENTS: (contextName: string) => string;
+                ENTITY_PROPERTY_UPDATE_EVENTS: (contextName: string) => string;
+            };
+            UNSUBSCRIBE: {
+                CUSTOM: (contextName: string) => string;
+                ENTITY_UPDATE_EVENTS: (contextName: string) => string;
+                ENTITY_PROPERTY_UPDATE_EVENTS: (contextName: string) => string;
+            };
+        };
+    };
+    const metadata: {
+        className: string;
+        options: {
+            runtimeController: string;
+            controller: string;
+            controllerMethod: string;
+            entity: string;
+            repository: string;
+            provider: string;
+            subscriber: string;
+        };
+    };
+    const old: {
+        HAS_TABLE_IN_DB: symbol;
+        MDC_KEY: string;
+        WEBSQL_REST_PROGRESS_FUN: symbol;
+        WEBSQL_REST_PROGRESS_FUN_START: symbol;
+        WEBSQL_REST_PROGRESS_FUN_DONE: symbol;
+        WEBSQL_REST_PROGRESS_TIMEOUT: symbol;
+        X_TOTAL_COUNT: string;
+        CIRCURAL_OBJECTS_MAP_BODY: string;
+        CIRCURAL_OBJECTS_MAP_QUERY_PARAM: string;
+        MAPPING_CONFIG_HEADER: string;
+        MAPPING_CONFIG_HEADER_BODY_PARAMS: string;
+        MAPPING_CONFIG_HEADER_QUERY_PARAMS: string;
+        ENDPOINT_META_CONFIG: string;
+        CLASS_DECORATOR_CONTEXT: string;
+        SOCKET_MSG: string;
+        ANGULAR: {
+            INPUT_NAMES: symbol;
+        };
+        ERROR_MESSAGES: {
+            CLASS_NAME_MATCH: string;
+        };
+    };
+}

package/client/lib/ui/taon-admin-mode-configuration/models/taon-admin-mode-tabs.d.ts

@@ -0,0 +1,6 @@
+// @ts-nocheck
+import { TemplateRef } from '@angular/core';
+export interface TaonAdminModeTab {
+    name: string;
+    template: TemplateRef<any>;
+}

package/client/lib/ui/taon-admin-mode-configuration/taon-admin-control.service.d.ts

@@ -0,0 +1,18 @@
+// @ts-nocheck
+import { ApplicationRef, TemplateRef } from '@angular/core';
+import type { TaonAdminModeConfigurationComponent } from './taon-admin-mode-configuration.component';
+import * as i0 from "@angular/core";
+export declare class TaonAdminService {
+    private cdr;
+    taonAdminModeConfigurationComponent: TaonAdminModeConfigurationComponent;
+    private readonly admin;
+    /**
+     * @deprecated
+     */
+    disableScroll(): void;
+    constructor(cdr: ApplicationRef);
+    addTab(name: string, template: TemplateRef<any>): void;
+    init(taonAdminModeConfigurationComponent: TaonAdminModeConfigurationComponent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaonAdminService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TaonAdminService>;
+}

package/client/lib/ui/taon-admin-mode-configuration/taon-admin-mode-configuration.component.d.ts

@@ -0,0 +1,51 @@
+// @ts-nocheck
+import { ChangeDetectorRef, EventEmitter, OnInit } from '@angular/core';
+import { TaonAdmin } from './taon-admin.service';
+import { CdkDragEnd, Point } from '@angular/cdk/drag-drop';
+import { BreakpointsService } from 'static-columns/browser';
+import { Subject } from 'rxjs';
+import { TaonAdminModeTab } from './models/taon-admin-mode-tabs';
+import { TaonAdminService } from './taon-admin-control.service';
+import * as i0 from "@angular/core";
+export declare class TaonAdminModeConfigurationComponent implements OnInit {
+    private breakpointsService;
+    $destroy: Subject<unknown>;
+    readonly cdr: ChangeDetectorRef;
+    readonly taonAdminService: TaonAdminService;
+    readonly isDesktop: boolean;
+    tabs: TaonAdminModeTab[];
+    admin: TaonAdmin;
+    isWebSQLMode: boolean;
+    hideTaonToolsInProduction: boolean;
+    isIframe: boolean;
+    height: number;
+    openedOnce: boolean;
+    reloading: boolean;
+    showPasscode: boolean;
+    passcode: string;
+    message: string;
+    dragPositionX: number;
+    dragPositionY: number;
+    dragPositionZero: Point;
+    dragPosition: Point;
+    selectedIndex: number;
+    tabGroup: any;
+    wasOpenDraggablePopup: boolean;
+    taonAdminModeConfigurationDataChanged: EventEmitter<any>;
+    taonAdminModeConfigurationData: any;
+    get opened(): boolean;
+    set opened(v: boolean);
+    constructor(breakpointsService: BreakpointsService);
+    reloadTabs(): void;
+    ngOnInit(): Promise<void>;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    onResize(event: Event): void;
+    toogle(): Promise<void>;
+    toogleFullScreen(): Promise<void>;
+    resetDrag(): void;
+    moved(c: CdkDragEnd): void;
+    scrollTabs(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaonAdminModeConfigurationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TaonAdminModeConfigurationComponent, "app-taon-admin-mode-configuration", never, { "taonAdminModeConfigurationData": { "alias": "taonAdminModeConfigurationData"; "required": false; }; }, { "taonAdminModeConfigurationDataChanged": "taonAdminModeConfigurationDataChanged"; }, never, ["*"], false, never>;
+}

package/client/lib/ui/taon-admin-mode-configuration/taon-admin.service.d.ts

@@ -0,0 +1,25 @@
+// @ts-nocheck
+import type { TaonAdminModeConfigurationComponent } from './taon-admin-mode-configuration.component';
+import * as i0 from "@angular/core";
+export declare class TaonAdmin {
+    scrollableEnabled: boolean;
+    private constructor();
+    static get Instance(): TaonAdmin;
+    cmp: TaonAdminModeConfigurationComponent;
+    private onEditMode;
+    onEditMode$: import("rxjs").Observable<unknown>;
+    adminPanelIsOpen: boolean;
+    draggablePopupMode: boolean;
+    draggablePopupModeFullScreen: boolean;
+    /**
+     * Property used in taon
+     */ keepWebsqlDbDataAfterReload: boolean;
+    setEditMode(value: boolean): void;
+    setKeepWebsqlDbDataAfterReload(value: boolean): void;
+    enabledTabs: any[];
+    hide(): void;
+    show(): void;
+    logout(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaonAdmin, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TaonAdmin>;
+}

package/client/lib/validators.d.ts

@@ -0,0 +1,8 @@
+// @ts-nocheck
+import { Models } from './models';
+export declare namespace Validators {
+    const classNameVlidation: (className: any, target: Function) => any;
+    const checkIfMethodsWithReponseTYpeAlowed: (methods: Models.MethodConfig[], current: Models.MethodConfig) => void;
+    const validateClassFunctions: (controllers: any[], entities: any[], proviers: any[], repositories: any[]) => void;
+    const preventUndefinedModel: (model: any, id: any) => void;
+}

package/client/public-api.d.ts

@@ -0,0 +1,2 @@
+// @ts-nocheck
+export * from './lib';

package/index.d.ts

@@ -0,0 +1 @@
+export * from './lib';

package/index.js

@@ -1 +1,5 @@
-console.log('Hello from taon')
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./lib"), exports);
+//# sourceMappingURL=index.js.map

package/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":[""],"names":[],"mappings":";;;AAAA,gDAAsB"}

package/lib/base-classes/base-abstract-entity.d.ts

@@ -0,0 +1,6 @@
+import { BaseEntity } from './base-entity';
+import type { BaseClass } from './base-class';
+export declare abstract class BaseAbstractEntity<CloneT extends BaseClass = any> extends BaseEntity<CloneT> {
+    id: string;
+    version: number;
+}

package/lib/base-classes/base-abstract-entity.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseAbstractEntity = void 0;
+var tslib_1 = require("tslib");
+//#region @websql
+var taon_typeorm_1 = require("taon-typeorm");
+//#endregion
+var orm_1 = require("../orm");
+var base_entity_1 = require("./base-entity");
+// empty decorator
+var EntityDecorator = function () {
+    return function (target) { };
+};
+//#region @websql
+EntityDecorator = taon_typeorm_1.Entity;
+//#endregion
+var BaseAbstractEntity = /** @class */ (function (_super) {
+    tslib_1.__extends(BaseAbstractEntity, _super);
+    function BaseAbstractEntity() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    tslib_1.__decorate([
+        orm_1.Orm.Column.Generated()
+        //#endregion
+        ,
+        tslib_1.__metadata("design:type", String)
+    ], BaseAbstractEntity.prototype, "id", void 0);
+    tslib_1.__decorate([
+        orm_1.Orm.Column.Version()
+        //#endregion
+        ,
+        tslib_1.__metadata("design:type", Number)
+    ], BaseAbstractEntity.prototype, "version", void 0);
+    BaseAbstractEntity = tslib_1.__decorate([
+        EntityDecorator()
+    ], BaseAbstractEntity);
+    return BaseAbstractEntity;
+}(base_entity_1.BaseEntity));
+exports.BaseAbstractEntity = BaseAbstractEntity;
+//# sourceMappingURL=base-abstract-entity.js.map

package/lib/base-classes/base-abstract-entity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-abstract-entity.js","sourceRoot":"","sources":[""],"names":[],"mappings":";;;;AAAA,iBAAiB;AACjB,6CAAsC;AACtC,YAAY;AACZ,8BAA6B;AAC7B,6CAA2C;AAG3C,kBAAkB;AAClB,IAAI,eAAe,GAAG;IACpB,OAAO,UAAC,MAAW,IAAM,CAAC,CAAC;AAC7B,CAAC,CAAC;AAEF,iBAAiB;AACjB,eAAe,GAAG,qBAAM,CAAC;AACzB,YAAY;AAGZ;IAEU,8CAAkB;IAF5B;;IAYA,CAAC;IANC;QAFC,SAAG,CAAC,MAAM,CAAC,SAAS,EAAE;QACvB,YAAY;;;kDACD;IAKX;QAFC,SAAG,CAAC,MAAM,CAAC,OAAO,EAAE;QACrB,YAAY;;;uDACI;IAXI,kBAAkB;QADvC,eAAe,EAAE;OACI,kBAAkB,CAYvC;IAAD,yBAAC;CAAA,AAZD,CAEU,wBAAU,GAUnB;AAZqB,gDAAkB"}

package/lib/base-classes/base-class.d.ts

@@ -0,0 +1,8 @@
+export declare class BaseClass<CloneT extends BaseClass = any> {
+    /**
+     * class initialization hook
+     * taon after class instace creation
+     */
+    _(): Promise<void>;
+    clone(override: Partial<CloneT>): CloneT;
+}

package/lib/base-classes/base-class.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseClass = void 0;
+var tslib_1 = require("tslib");
+//#region imports
+var tnp_core_1 = require("tnp-core");
+var class_helpers_1 = require("../helpers/class-helpers");
+/* */
+/* */
+//#endregion
+var BaseClass = /** @class */ (function () {
+    function BaseClass() {
+    }
+    //#region class initialization hook
+    /**
+     * class initialization hook
+     * taon after class instace creation
+     */
+    BaseClass.prototype._ = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
+            return [2 /*return*/];
+        }); });
+    };
+    //#endregion
+    //#region clone
+    BaseClass.prototype.clone = function (override) {
+        var classFn = class_helpers_1.ClassHelpers.getClassFnFromObject(this);
+        var result = tnp_core_1._.merge(new classFn(), tnp_core_1._.merge(tnp_core_1._.cloneDeep(this), override));
+        // console.log({result})
+        return result;
+    };
+    return BaseClass;
+}());
+exports.BaseClass = BaseClass;
+//# sourceMappingURL=base-class.js.map

package/lib/base-classes/base-class.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-class.js","sourceRoot":"","sources":[""],"names":[],"mappings":";;;;AAAA,iBAAiB;AACjB,qCAAsC;AAGtC,0DAAwD;AAExD,KAAK;AACL,KAAK;AAEL,YAAY;AAEZ;IAAA;IAiBA,CAAC;IAhBC,mCAAmC;IACnC;;;OAGG;IACG,qBAAC,GAAP;;;;KAAY;IACZ,YAAY;IAEZ,eAAe;IACR,yBAAK,GAAZ,UAAa,QAAyB;QACpC,IAAM,OAAO,GAAG,4BAAY,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC;QACxD,IAAM,MAAM,GAAG,YAAC,CAAC,KAAK,CAAC,IAAI,OAAO,EAAE,EAAE,YAAC,CAAC,KAAK,CAAC,YAAC,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC;QAC5E,wBAAwB;QACxB,OAAO,MAAM,CAAC;IAChB,CAAC;IAEH,gBAAC;AAAD,CAAC,AAjBD,IAiBC;AAjBY,8BAAS"}

package/lib/base-classes/base-context.d.ts

@@ -0,0 +1,16 @@
+declare const BaseContext: {
+    types: {
+        readonly controllers: Record<string, new (...args: any[]) => any>;
+        readonly repositories: Record<string, new (...args: any[]) => any>;
+        readonly providers: Record<string, new (...args: any[]) => any>;
+        readonly subscribers: Record<string, new (...args: any[]) => any>;
+    };
+    readonly contexts: Record<string, object>;
+    readonly contextName: string;
+    __ref(): Promise<import("../endpoint-context").EndpointContext>;
+    readonly __refSync: import("../endpoint-context").EndpointContext;
+    getClassInstance<T>(ctor: new (...args: any[]) => T): T;
+    getClass<T>(ctor: new (...args: any[]) => T): new (...args: any[]) => T;
+    initialize: () => Promise<import("../endpoint-context").EndpointContext>;
+};
+export { BaseContext };

package/lib/base-classes/base-context.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseContext = void 0;
+var create_context_1 = require("../create-context");
+var base_repository_1 = require("./base-repository");
+var BaseContext = (0, create_context_1.createContext)(function () { return ({
+    contextName: 'BaseContext',
+    abstract: true,
+    repositories: {
+        // @ts-ignore
+        BaseRepository: base_repository_1.BaseRepository,
+    },
+}); });
+exports.BaseContext = BaseContext;
+//# sourceMappingURL=base-context.js.map

package/lib/base-classes/base-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-context.js","sourceRoot":"","sources":[""],"names":[],"mappings":";;;AAAA,oDAAkD;AAClD,qDAAmD;AAEnD,IAAM,WAAW,GAAG,IAAA,8BAAa,EAAC,cAAM,OAAA,CAAC;IACvC,WAAW,EAAE,aAAa;IAC1B,QAAQ,EAAE,IAAI;IACd,YAAY,EAAE;QACZ,aAAa;QACb,cAAc,kCAAA;KACf;CACF,CAAC,EAPsC,CAOtC,CAAC,CAAC;AAEK,kCAAW"}

package/lib/base-classes/base-controller.d.ts

@@ -0,0 +1,7 @@
+import { BaseInjector } from './base-injector';
+export declare class BaseController extends BaseInjector {
+    /**
+     * init example data for db
+     */
+    initExampleDbData(): Promise<any>;
+}

package/lib/base-classes/base-controller.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseController = void 0;
+var tslib_1 = require("tslib");
+var controller_decorator_1 = require("../decorators/classes/controller-decorator");
+var base_injector_1 = require("./base-injector");
+var BaseController = /** @class */ (function (_super) {
+    tslib_1.__extends(BaseController, _super);
+    function BaseController() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    /**
+     * init example data for db
+     */
+    BaseController.prototype.initExampleDbData = function () {
+        return void 0;
+    };
+    BaseController = tslib_1.__decorate([
+        (0, controller_decorator_1.TaonController)({ className: 'BaseController' })
+    ], BaseController);
+    return BaseController;
+}(base_injector_1.BaseInjector));
+exports.BaseController = BaseController;
+//# sourceMappingURL=base-controller.js.map

package/lib/base-classes/base-controller.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-controller.js","sourceRoot":"","sources":[""],"names":[],"mappings":";;;;AAAA,mFAA4E;AAC5E,iDAA+C;AAG/C;IAAoC,0CAAY;IAAhD;;IASA,CAAC;IARC;;OAEG;IACH,0CAAiB,GAAjB;QACE,OAAO,KAAK,CAAC,CAAC;IAChB,CAAC;IANU,cAAc;QAD1B,IAAA,qCAAc,EAAC,EAAE,SAAS,EAAE,gBAAgB,EAAE,CAAC;OACnC,cAAc,CAS1B;IAAD,qBAAC;CAAA,AATD,CAAoC,4BAAY,GAS/C;AATY,wCAAc"}

package/lib/base-classes/base-crud-controller.d.ts

@@ -0,0 +1,27 @@
+import { BaseController } from './base-controller';
+import { BaseRepository } from './base-repository';
+import { Models } from '../models';
+/**
+ * Please override property entityClassFn with entity class.
+ */
+export declare abstract class BaseCrudController<Entity> extends BaseController {
+    protected db?: BaseRepository<Entity>;
+    /**
+     * Please provide entity as class propery entityClassFn:
+     * @returns class function
+     *
+     */
+    abstract entityClassResolveFn: () => any;
+    _(): Promise<void>;
+    bufforedChanges(id: number | string, property: string, alreadyLength?: number): Models.Http.Response<string | any[]>;
+    pagination(pageNumber?: number, pageSize?: number, search?: string): Models.Http.Response<Entity[]>;
+    getAll(): Models.Http.Response<Entity[]>;
+    getBy(id: number | string): Models.Http.Response<Entity>;
+    updateById(id: number | string, item: Entity): Models.Http.Response<Entity>;
+    patchById(id: number | string, item: Entity): Models.Http.Response<Entity>;
+    bulkUpdate(items: Entity[]): Models.Http.Response<Entity[]>;
+    deleteById(id: number): Models.Http.Response<Entity>;
+    bulkDelete(ids: (number | string)[]): Models.Http.Response<(number | string | Entity)[]>;
+    create(item: Entity): Models.Http.Response<Entity>;
+    bulkCreate(items: Entity): Models.Http.Response<Entity[]>;
+}