taon 19.0.86 → 21.0.6

package/websql/lib/models.d.ts

@@ -1,261 +0,0 @@
-// @ts-nocheck
-import type { RequestHandler } from 'express';
-import { Response as ExpressResponse, Request as ExpressRequest } from 'express';
-import { Models as ModelsNg2Rest, RestResponseWrapper } from 'ng2-rest/websql';
-import { CoreModels } from 'tnp-core/websql';
-import type { EndpointContext } from './endpoint-context';
-export declare class TaonRestResponseWrapper extends RestResponseWrapper {
-}
-export declare const BaseTaonClassesNames: readonly ["BaseCrudController", "BaseController", "BaseAbstractEntity", "BaseEntity", "BaseContext", "BaseCustomRepository", "BaseFileUploadMiddleware", "BaseMiddleware", "BaseClass", "BaseInjector", "BaseMigration", "BaseProvider", "BaseRepository", "BaseSubscriberForEntity", "BaseCliWorkerController", "PortsController", "PortsContext"];
-export declare const TaonTempDatabasesFolder = "databases";
-export declare const TaonTempRoutesFolder = "routes";
-export declare namespace Models {
-    const DatabasesFolder = "databases";
-    type FrameworkMode = 'backend-frontend(tcp+udp)' | 'remote-backend(tcp+udp)' | 'backend-frontend(ipc-electron)' | 'backend-frontend(websql-electron)' | 'backend-frontend(websql)';
-    enum ClassType {
-        ENTITY = "ENTITY",
-        CONTROLLER = "CONTROLLER",
-        REPOSITORY = "REPOSITORY",
-        PROVIDER = "PROVIDER",
-        SUBSCRIBER = "SUBSCRIBER",
-        MIGRATION = "MIGRATION",
-        MIDDLEWARE = "MIDDLEWARE"
-    }
-    const ClassTypeKey: { [key in ClassType]: keyof ContextOptions<any, any, any, any, any, any, any, any>; };
-    type MiddlewareType = [Function, any[]];
-    /**
-     * DROP_DB+MIGRATIONS (default for development)
-     * Drop all tables + recreate them + run migrations
-     * synchronize: true , dropSchema: true
-     * use migrations: true
-     *
-     * MIGRATIONS (default for production)
-     * Do not drop tables, only run migrations
-     * synchronize: false, dropSchema: false
-     * use migrations: true
-     */
-    type DBRecreateMode = 'DROP_DB+MIGRATIONS' | 'PRESERVE_DATA+MIGRATIONS';
-    class DatabaseConfigTypeOrm {
-        /**
-         * database name
-         */
-        database?: string;
-        /**
-         * only for file base db: sqlite, sqljs
-         */
-        location?: string;
-        synchronize: boolean;
-        dropSchema: boolean;
-        type?: CoreModels.DatabaseType;
-        /**
-         * Persists db on disk/local-storage if serverless db
-         */
-        autoSave?: boolean;
-        /**
-         * for websql db mode
-         * true by default
-         */
-        useLocalForage?: boolean;
-        logging: boolean;
-        databasePort?: number;
-        databaseHost?: string;
-        databaseUsername?: string;
-        databasePassword?: string;
-    }
-    class DatabaseConfig extends DatabaseConfigTypeOrm {
-        /**
-         * Default value 'DROP_ALL'.
-         *
-         * Tell framework what is happening with db
-         * when context is starting.
-         */
-        recreateMode?: DBRecreateMode;
-        static from(databasePartialConfig: Partial<Omit<DatabaseConfig, 'synchronize' | 'dropSchema' | 'databaseConfigTypeORM'>>): DatabaseConfig;
-        get databaseConfigTypeORM(): DatabaseConfigTypeOrm;
-    }
-    type ISession = {
-        secret?: string;
-        saveUninitialized?: boolean;
-        /**
-         * max age of session
-         */
-        cookieMaxAge?: number;
-        secure?: boolean;
-        resave?: boolean;
-    };
-    type ConnectionOptionsLogs = {
-        http?: boolean;
-        realtime?: boolean;
-        framework?: boolean;
-        db?: boolean;
-        migrations?: boolean;
-        routes?: boolean;
-    };
-    interface ContextOptions<CONTEXTS, CONTROLLERS, ENTITIES, REPOSITORIES, PROVIDERS, SUBSCRIBERS, MIGRATIONS, MIDDLEWARES> {
-        appId?: string;
-        contextName: string;
-        /**
-         * if defined and different from contextName
-         * - context will NOT be initialized
-         */
-        activeContext?: string | null;
-        /**
-         * IMPORTANT! provide full url that starts with http:// or https://
-         * host/port for initing backend server
-         */
-        host?: string;
-        /**
-         * Needs to be specified in docker environment only
-         */
-        hostPortNumber?: number;
-        /**
-         * IMPORTANT! provide full url that starts with http:// or https://
-         * frontend host only needed when we are
-         * using withCredentials for axios
-         * and session cookie
-         * or realtime communication
-         */
-        frontendHost?: string;
-        /**
-         * Needs to be specified in docker environment only
-         */
-        frontendHostPortNumber?: number;
-        /**
-         * User ipc for communication between BE/FE
-         * when electron is used as a platform
-         * Default: true
-         */
-        useIpcWhenElectron?: boolean;
-        /**
-         * taon contexts here
-         * (module like structure)
-         */
-        contexts?: CONTEXTS;
-        /**
-         * taon controller here
-         * (glue between frontend and backend)
-         */
-        controllers?: CONTROLLERS;
-        /**
-         * taon entities
-         * (entities are used to create tables in db)
-         */
-        entities?: ENTITIES;
-        /**
-         * taon repositories
-         * (repositories are used to access data from db)
-         */
-        repositories?: REPOSITORIES;
-        /**
-         * taon providers
-         * (context singletons)
-         */
-        providers?: PROVIDERS;
-        /**
-         * taon subscribers
-         * (subscribers are used to listen to db events)
-         */
-        subscribers?: SUBSCRIBERS;
-        /**
-         * taon migrations
-         * (migrations are used to update db schema and achieve proper CI/CD)
-         */
-        migrations?: MIGRATIONS;
-        /**
-         * taon middlewares
-         * middlewares are used to intercept requests
-         * and responses in the context
-         */
-        middlewares?: MIDDLEWARES;
-        /**
-         * Config for express session
-         */
-        session?: ISession;
-        /**
-         * taon is not going to write .rest files to cwd()
-         */
-        skipWritingServerRoutes?: boolean;
-        /**
-         * TODO - this is still in progress
-         * @deprecated
-         */
-        productionMode?: boolean;
-        /**
-         * If you want your context to never be started as separated server
-         * use abstract: true
-         * @default: false
-         */
-        abstract?: boolean;
-        logs?: boolean | ConnectionOptionsLogs;
-        database?: boolean | Partial<DatabaseConfig>;
-        /**
-         * disable default realtime communication through TCP upgrade sockets
-         */
-        disabledRealtime?: boolean;
-        /**
-         * Will be removed soon - cloud will handle certs and https
-         * @deprecated
-         */
-        https?: {
-            key: string;
-            cert: string;
-        };
-        /**
-         * TODO - will be removed soon
-         * @deprecated
-         */
-        publicAssets?: {
-            serverPath: string;
-            locationOnDisk: string;
-        }[];
-        /**
-         * by default cwd === process.cwd()
-         */
-        cwd?: string;
-    }
-    namespace Http {
-        export import Rest = ModelsNg2Rest;
-        type ContextENDPOINT = {
-            target: Function;
-            initFN: Function;
-        };
-        type FormlyFromType = 'material' | 'bootstrap';
-        type ExpressContext<T> = (req: ExpressRequest, res: ExpressResponse) => T;
-        type SyncResponse<T> = string | T;
-        type ResponseFuncOpt<T> = {
-            limitSize?: (enties: Function | Function[], include: string[], exclude: string[]) => void;
-        };
-        type SyncResponseFunc<T> = (options?: ResponseFuncOpt<T>) => SyncResponse<T>;
-        type MixResponse<T> = SyncResponse<T> | ExpressContext<T>;
-        interface ClientAction<T> {
-            /**
-             * @deprecated use request() mehods instead
-             */
-            readonly received?: Rest.PromiseObservableMix<Rest.HttpResponse<T>>;
-            request?(axiosConfig?: ModelsNg2Rest.Ng2RestAxiosRequestConfig): Rest.PromiseObservableMix<Rest.HttpResponse<T>>;
-        }
-        interface AsyncResponse<T> {
-            (req?: ExpressRequest, res?: ExpressResponse): Promise<SyncResponse<T> | SyncResponseFunc<T>>;
-        }
-        type Response<T = string> = AsyncResponse<T> & ClientAction<T>;
-        interface AuthCallBack {
-            (methodReference: Function): RequestHandler;
-        }
-    }
-    interface StartParams {
-        port: number;
-        args: string[];
-        onlyMigrationRun?: boolean;
-        onlyMigrationRevertToTimestamp?: number;
-    }
-    interface TaonInitializeParams {
-        onlyMigrationRun?: boolean;
-        onlyMigrationRevertToTimestamp?: number;
-    }
-    interface TaonCtxCloneParams {
-        useAsRemoteContext?: boolean;
-        overrideRemoteHost?: string;
-        overrideHost?: string;
-        sourceContext?: EndpointContext;
-    }
-}

package/websql/lib/orm.d.ts

@@ -1,69 +0,0 @@
-// @ts-nocheck
-import * as tsorm from 'taon-typeorm/websql';
-export declare namespace Orm {
-    const Repository: typeof tsorm.Repository;
-    export import Connection = tsorm.Connection;
-    namespace ListenEvent {
-        export import AfterInsert = tsorm.AfterInsert;
-        export import AfterLoad = tsorm.AfterLoad;
-        export import AfterRecover = tsorm.AfterRecover;
-        export import AfterRemove = tsorm.AfterRemove;
-        export import AfterSoftRemove = tsorm.AfterSoftRemove;
-        export import AfterUpdate = tsorm.AfterUpdate;
-        export import BeforeInsert = tsorm.BeforeInsert;
-        export import BeforeRecover = tsorm.BeforeRecover;
-        export import BeforeRemove = tsorm.BeforeRemove;
-        export import BeforeSoftRemove = tsorm.BeforeSoftRemove;
-        export import BeforeUpdate = tsorm.BeforeUpdate;
-    }
-    namespace Tree {
-        export import Children = tsorm.TreeChildren;
-        export import Parent = tsorm.TreeParent;
-    }
-    namespace Column {
-        export import Generated = tsorm.PrimaryGeneratedColumn;
-        export import Primary = tsorm.PrimaryColumn;
-        export import Index = tsorm.Index;
-        export import CreateDate = tsorm.CreateDateColumn;
-        export import UpdateDate = tsorm.UpdateDateColumn;
-        export import DeleteDate = tsorm.DeleteDateColumn;
-        export import Custom = tsorm.Column;
-        /**
-         * 100 default characters varchar
-         */
-        const String: <T = string>(defaultValue?: T, length?: number) => PropertyDecorator;
-        /**
-         * 100 characters varchar
-         */
-        const String100: <T = string>(defaultValue?: T) => PropertyDecorator;
-        /**
-         * 100 characters varchar
-         */
-        const String45: <T = string>(defaultValue?: T) => PropertyDecorator;
-        /**
-         * 500 characters varchar
-         */
-        const String500: <T = string>(defaultValue?: T) => PropertyDecorator;
-        /**
-         * 200 characters varchar
-         */
-        const String200: <T = string>(defaultValue?: T) => PropertyDecorator;
-        const Number: () => PropertyDecorator;
-        const DecimalNumber: () => PropertyDecorator;
-        const SimpleJson: () => PropertyDecorator;
-        const Boolean: (defaultValue: boolean | null) => PropertyDecorator;
-        const DateTIme: (defaultValue?: boolean | null) => PropertyDecorator;
-        export import Version = tsorm.VersionColumn;
-        export import Virtual = tsorm.VirtualColumn;
-    }
-    namespace Join {
-        export import Table = tsorm.JoinTable;
-        export import Column = tsorm.JoinColumn;
-    }
-    namespace Relation {
-        export import OneToMany = tsorm.OneToMany;
-        export import OneToOne = tsorm.OneToOne;
-        export import ManyToMany = tsorm.ManyToMany;
-        export import ManyToOne = tsorm.ManyToOne;
-    }
-}

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

@@ -1,42 +0,0 @@
-// @ts-nocheck
-import { Observable } from 'rxjs';
-import { RealtimeCore } from './realtime-core';
-import { RealtimeModels } from './realtime.models';
-/**
- * Client for realtime communication
- * you can listen to:
- * - entity changes (any property in table changed)
- * - entity custom property changes (specific property changed)
- * - entity table changes (new instance added, instance removed)
- * - custom events
- */
-export declare class RealtimeClient {
-    private core;
-    private subsManagers;
-    constructor(core: RealtimeCore);
-    private init;
-    /**
-     * Usage:
-     * myContext.realtimeClient.listenChangesEntity(myEntityInstance);
-     *
-     *
-     * Changes trigger on backend needs to be done manually.. example code:
-     *
-     * myContext.realtimeServer.triggerEntityChanges(myEntityInstance);
-     * ...
-     */
-    listenChangesEntity<RESULT = any>(entityClassFnOrObj: Function | object, options?: RealtimeModels.ChangeOption): Observable<RESULT>;
-    /**
-     * Listen changes entity table
-     * Example: for pagination, lists update ...
-     */
-    listenChangesEntityTable<RESULT = any>(entityClassFn: Function): Observable<RESULT>;
-    listenChangesCustomEvent<RESULT = any>(customEvent: string): Observable<RESULT>;
-    /**
-     * Trigger custom event on backend
-     * @param customEvent global event name
-     * @param dataToPush
-     */
-    triggerCustomEvent(customEvent: string, dataToPush?: any): void;
-    private getUniqueIdentifierForConnection;
-}

package/websql/lib/realtime/realtime-core.d.ts

@@ -1,41 +0,0 @@
-// @ts-nocheck
-import { Server } from 'socket.io';
-import { DefaultEventsMap } from 'socket.io/dist/typed-events';
-import { Socket as SocketClient } from 'socket.io-client';
-import type { EndpointContext } from '../endpoint-context';
-import { RealtimeClient } from './realtime-client';
-import { RealtimeServer } from './realtime-server';
-import type { RealtimeStrategy } from './realtime-strategy';
-/**
- * Realtime class
- * - mock (when browser-browser)
- * - sockets (from socket io when backend-browser)
- * - ipc (when electron is used or between processes)
- * - webworker (when webworker is used in browser or nodejs)
- */
-export declare class RealtimeCore {
-    ctx: EndpointContext;
-    readonly allHttpMethods: string[];
-    readonly client: RealtimeClient;
-    readonly server: RealtimeServer;
-    readonly strategy: RealtimeStrategy;
-    /**
-     * global FE socket - only for established connection
-     */
-    conectSocketFE: SocketClient<DefaultEventsMap, DefaultEventsMap>;
-    /**
-     * socket for namespaces and rooms
-     */
-    socketFE: SocketClient<DefaultEventsMap, DefaultEventsMap>;
-    /**
-     * global BE socket - only for established connection
-     */
-    connectSocketBE: Server<DefaultEventsMap, DefaultEventsMap, DefaultEventsMap, any>;
-    /**
-     * socket for namespaces and rooms
-     */
-    socketBE: Server<DefaultEventsMap, DefaultEventsMap, DefaultEventsMap, any>;
-    constructor(ctx: EndpointContext);
-    private resolveStrategy;
-    pathFor(namespace?: string): URL;
-}

package/websql/lib/realtime/realtime-server.d.ts

@@ -1,44 +0,0 @@
-// @ts-nocheck
-import { Observable } from 'rxjs';
-import { RealtimeCore } from './realtime-core';
-/**
- * Server for realtime communication
- * you can trigger:
- * - entity changes (any property in table changed)
- * - entity custom property changes (specific property changed)
- * - entity table changes (new instance added, instance removed)
- * - custom events
- *
- * and also listen to:
- * - custom events from yourself
- */
-export declare class RealtimeServer {
-    private core;
-    constructor(core: RealtimeCore);
-    private init;
-    private triggerChanges;
-    triggerEntityChanges(entityObjOrClass: Function | object, 
-    /**
-     * value of unique key property of entity instance
-     * (this value is not needed if entityObjOrClass is instance of entity)
-     */
-    idToTrigger?: number | string): void;
-    triggerEntityPropertyChanges(entityObjOrClass: Function | object, 
-    /**
-     * property name or array of property names that changed
-     * for entity instance
-     */
-    property: string | string[], 
-    /**
-     * value of unique key property of entity instance
-     * (this value is not needed if entityObjOrClass is instance of entity)
-     */
-    idToTrigger?: number | string): void;
-    triggerEntityTableChanges(entityClassOrInstance: Function | object): void;
-    triggerCustomEvent(customEvent: string, dataToPush: any): void;
-    /**
-     * Listen to custom events from users
-     * @param customEvent  global event name
-     */
-    listenChangesCustomEvent(customEvent: string): Observable<any>;
-}

package/websql/lib/realtime/realtime-strategy/index.d.ts

@@ -1,5 +0,0 @@
-// @ts-nocheck
-export * from './realtime-strategy';
-export * from './realtime-strategy-ipc';
-export * from './realtime-strategy-mock';
-export * from './realtime-strategy-socket-io';

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

@@ -1,82 +0,0 @@
-// @ts-nocheck
-import type { ipcRenderer } from 'electron';
-import { ServerOptions } from 'socket.io';
-import { EndpointContext } from '../../endpoint-context';
-import { RealtimeModels } from '../realtime.models';
-import { RealtimeStrategy } from './realtime-strategy';
-export declare class MockServerIpc {
-    contextName: string;
-    static serverByContextName: Map<string, MockServerIpc>;
-    static from(contextName: string): MockServerIpc;
-    namespacesByName: Map<string, MockNamespaceIpc>;
-    constructor(contextName: string);
-    of(namespace: string): MockNamespaceIpc;
-}
-export declare class MockNamespaceIpc {
-    /**
-     * Namespace name
-     */
-    name: string;
-    server: MockServerIpc;
-    electronClients: Set<Electron.WebContents>;
-    roomsByRoomName: {
-        [roomName: string]: Set<Electron.WebContents>;
-    };
-    private namespaceEventHandlers;
-    constructor(
-    /**
-     * Namespace name
-     */
-    name: string, server: MockServerIpc);
-    on(eventName: string, callback: RealtimeModels.EventHandler): any;
-    off(event: string, callback?: RealtimeModels.EventHandler): any;
-    emit(eventName: string, ...args: any[]): any;
-    to(roomName: string): RoomEmitterIpc;
-    in(roomName: string): RoomEmitterIpc;
-    join(webContents: Electron.WebContents, roomName: string): void;
-    leave(webContents: Electron.WebContents, roomName: string): void;
-    path(): string;
-    get nsp(): {
-        readonly name: string;
-    };
-}
-declare class RoomEmitterIpc {
-    private electronClients;
-    /**
-     * namespace name
-     */
-    private name;
-    private includeSender;
-    private sender;
-    constructor(electronClients: Set<Electron.WebContents>, 
-    /**
-     * namespace name
-     */
-    name: string, includeSender?: boolean, sender?: MockSocketIpc);
-    emit(eventName: string, ...args: any[]): void;
-}
-export declare class MockSocketIpc {
-    namespaceName: string;
-    ipcRenderer: typeof ipcRenderer;
-    private socketEventHandlers;
-    get name(): string;
-    /**
-     * @param namespaceName instead url for ipc
-     */
-    constructor(namespaceName: string);
-    on(eventName: string, callback: (event: any, ...args: any[]) => void): void;
-    off(event: string, callback?: (event: any, ...args: any[]) => void): void;
-    emit(event: string, ...args: any[]): void;
-}
-/**
- * Purpose:
- * - backend-browser communication between 2 processes in electron mode
- */
-export declare class RealtimeStrategyIpc extends RealtimeStrategy {
-    protected ctx: EndpointContext;
-    toString(): string;
-    constructor(ctx: EndpointContext);
-    ioServer(__: string, opt: ServerOptions): any;
-    get ioClient(): any;
-}
-export {};

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

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

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

@@ -1,16 +0,0 @@
-// @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);
-    ioServer(...args: any[]): any;
-    get ioClient(): typeof io;
-}

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

@@ -1,12 +0,0 @@
-// @ts-nocheck
-import { EndpointContext } from '../../endpoint-context';
-import type { Server, ServerOptions } from 'socket.io';
-import type { io } from 'socket.io-client';
-import { DefaultEventsMap } from 'socket.io/dist/typed-events';
-export declare abstract class RealtimeStrategy {
-    protected ctx: EndpointContext;
-    constructor(ctx: EndpointContext);
-    get ioClient(): typeof io;
-    ioServer(url: string, opt: ServerOptions): Server<DefaultEventsMap, DefaultEventsMap, DefaultEventsMap, any>;
-    abstract toString(): string;
-}

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

@@ -1,15 +0,0 @@
-// @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/websql/lib/realtime/realtime.models.d.ts

@@ -1,28 +0,0 @@
-// @ts-nocheck
-import type { RealtimeCore } from './realtime-core';
-export declare namespace RealtimeModels {
-    type SubsManagerOpt = {
-        core: RealtimeCore;
-        customEvent: string;
-        roomName: string;
-        property: string;
-    };
-    interface ChangeOption {
-        /**
-         * Specify property name to listen changes on that property only;
-         */
-        property?: string;
-        /**
-         * Override custom event name to listen
-         */
-        customEvent?: string;
-        /**
-         * Value from entity object.
-         * Key for this value is usually id or unique key
-         * property defined in entity decorator.
-         * TODO @LAST IMPLEMENT unique key support
-         */
-        idOrUniqValue?: any;
-    }
-    type EventHandler = (...args: any[]) => void;
-}