@journeyapps-labs/reactor-mod-data-browser 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @journeyapps-labs/reactor-mod-data-browser
+
+## 1.0.0
+
+### Major Changes
+
+- 60d9391: First release

package/README.md

@@ -0,0 +1,3 @@
+# Reactor module Databrowser
+
+This module acts as the scaffolding and core for the databrowser experience.

package/dist/@types/DataBrowserModule.d.ts

@@ -0,0 +1,7 @@
+import { AbstractReactorModule } from '@journeyapps-labs/reactor-mod';
+import { Container } from '@journeyapps-labs/common-ioc';
+export declare class DataBrowserModule extends AbstractReactorModule {
+    constructor();
+    register(ioc: Container): void;
+    init(ioc: Container): Promise<any>;
+}

package/dist/@types/actions/connections/AddConnectionAction.d.ts

@@ -0,0 +1,10 @@
+import { EntityAction, EntityActionEvent } from '@journeyapps-labs/reactor-mod';
+import { AbstractConnectionFactory } from '../../core/AbstractConnectionFactory';
+import { ConnectionStore } from '../../stores/ConnectionStore';
+export declare class AddConnectionAction extends EntityAction<AbstractConnectionFactory> {
+    static ID: string;
+    accessor connectionStore: ConnectionStore;
+    constructor();
+    fireEvent(event: EntityActionEvent<AbstractConnectionFactory>): Promise<any>;
+    static get(): AddConnectionAction;
+}

package/dist/@types/actions/connections/RemoveConnectionAction.d.ts

@@ -0,0 +1,10 @@
+import { EntityAction, EntityActionEvent } from '@journeyapps-labs/reactor-mod';
+import { ConnectionStore } from '../../stores/ConnectionStore';
+import { AbstractConnection } from '../../core/AbstractConnection';
+export declare class RemoveConnectionAction extends EntityAction<AbstractConnection> {
+    static ID: string;
+    accessor connectionStore: ConnectionStore;
+    constructor();
+    fireEvent(event: EntityActionEvent<AbstractConnection>): Promise<any>;
+    static get(): RemoveConnectionAction;
+}

package/dist/@types/actions/schema-definitions/CreateModelAction.d.ts

@@ -0,0 +1,9 @@
+import { EntityAction, EntityActionEvent, WorkspaceStore } from '@journeyapps-labs/reactor-mod';
+import { SchemaModelDefinition } from '../../core/SchemaModelDefinition';
+export declare class CreateModelAction extends EntityAction<SchemaModelDefinition> {
+    static ID: string;
+    accessor workspaceStore: WorkspaceStore;
+    constructor();
+    fireEvent(event: EntityActionEvent<SchemaModelDefinition>): Promise<any>;
+    static get(): CreateModelAction;
+}

package/dist/@types/actions/schema-definitions/QuerySchemaModelAction.d.ts

@@ -0,0 +1,9 @@
+import { EntityAction, EntityActionEvent, WorkspaceStore } from '@journeyapps-labs/reactor-mod';
+import { SchemaModelDefinition } from '../../core/SchemaModelDefinition';
+export declare class QuerySchemaModelAction extends EntityAction<SchemaModelDefinition> {
+    static ID: string;
+    accessor workspaceStore: WorkspaceStore;
+    constructor();
+    fireEvent(event: EntityActionEvent<SchemaModelDefinition>): Promise<any>;
+    static get(): QuerySchemaModelAction;
+}

package/dist/@types/actions/schema-model/EditSchemaModelAction.d.ts

@@ -0,0 +1,9 @@
+import { EntityAction, EntityActionEvent, WorkspaceStore } from '@journeyapps-labs/reactor-mod';
+import { SchemaModelObject } from '../../core/SchemaModelObject';
+export declare class EditSchemaModelAction extends EntityAction<SchemaModelObject> {
+    static ID: string;
+    accessor workspaceStore: WorkspaceStore;
+    constructor();
+    fireEvent(event: EntityActionEvent<SchemaModelObject>): Promise<any>;
+    static get(): EditSchemaModelAction;
+}

package/dist/@types/core/AbstractConnection.d.ts

@@ -0,0 +1,33 @@
+import { Database, ObjectType } from '@journeyapps/db';
+import { Schema } from '@journeyapps/parser-schema';
+import { AbstractConnectionFactory } from './AbstractConnectionFactory';
+import { SchemaModelDefinition } from './SchemaModelDefinition';
+import { BaseObserver } from '@journeyapps-labs/common-utils';
+import { Collection, LifecycleCollection } from '@journeyapps-labs/lib-reactor-data-layer';
+export interface AbstractConnectionSerialized {
+    factory: string;
+    id: string;
+    payload: any;
+}
+export interface AbstractConnectionListener {
+    removed: () => any;
+}
+export declare abstract class AbstractConnection extends BaseObserver<AbstractConnectionListener> {
+    factory: AbstractConnectionFactory;
+    id: string;
+    schema_models_collection: Collection<ObjectType>;
+    schema_models: LifecycleCollection<ObjectType, SchemaModelDefinition>;
+    constructor(factory: AbstractConnectionFactory);
+    getSchemaModelDefinitionByName(name: string): SchemaModelDefinition;
+    waitForSchemaModelDefinitionByName(name: string): Promise<SchemaModelDefinition>;
+    abstract getConnection(): Promise<Database>;
+    protected getSchema(): Promise<Schema>;
+    reload(): Promise<void>;
+    init(): Promise<void>;
+    protected getSchemaModelDefinitions(): Promise<SchemaModelDefinition[]>;
+    remove(): void;
+    serialize(): AbstractConnectionSerialized;
+    get name(): string;
+    abstract _serialize(): any;
+    abstract _deSerialize(data: ReturnType<this['_serialize']>): Promise<any>;
+}

package/dist/@types/core/AbstractConnectionFactory.d.ts

@@ -0,0 +1,11 @@
+import { AbstractConnection } from './AbstractConnection';
+export interface ConnectionFactoryOptions {
+    label: string;
+    key: string;
+}
+export declare abstract class AbstractConnectionFactory<T extends AbstractConnection = AbstractConnection> {
+    options: ConnectionFactoryOptions;
+    constructor(options: ConnectionFactoryOptions);
+    abstract generateConnection(): T;
+    abstract generateConnectionFromUI(): Promise<T | null>;
+}

package/dist/@types/core/SchemaModelDefinition.d.ts

@@ -0,0 +1,20 @@
+import { AbstractConnection } from './AbstractConnection';
+import { ObjectType } from '@journeyapps/parser-schema';
+import { Collection } from '@journeyapps/db';
+import { SchemaModelObject } from './SchemaModelObject';
+import { LifecycleModel } from '@journeyapps-labs/lib-reactor-data-layer';
+export interface SchemaModelDefinitionOptions {
+    connection: AbstractConnection;
+    definition: ObjectType;
+}
+export declare class SchemaModelDefinition implements LifecycleModel<ObjectType> {
+    protected options: SchemaModelDefinitionOptions;
+    constructor(options: SchemaModelDefinitionOptions);
+    get key(): string;
+    dispose(): void;
+    patch(data: ObjectType): void;
+    get connection(): AbstractConnection;
+    get definition(): ObjectType;
+    getCollection(): Promise<Collection<import("@journeyapps/db").DatabaseObject>>;
+    generateNewModelObject(): Promise<SchemaModelObject>;
+}

package/dist/@types/core/SchemaModelObject.d.ts

@@ -0,0 +1,12 @@
+import { DatabaseObject } from '@journeyapps/db';
+import { SchemaModelDefinition } from './SchemaModelDefinition';
+export interface SchemaModelObjectOptions {
+    definition: SchemaModelDefinition;
+    model?: DatabaseObject;
+}
+export declare class SchemaModelObject {
+    options: SchemaModelObjectOptions;
+    constructor(options: SchemaModelObjectOptions);
+    get definition(): SchemaModelDefinition;
+    get model(): DatabaseObject;
+}

package/dist/@types/core/query/AbstractQuery.d.ts

@@ -0,0 +1,22 @@
+import { Page } from './Page';
+import { AbstractConnection } from '../AbstractConnection';
+import { ConnectionStore } from '../../stores/ConnectionStore';
+import { TableColumn } from '@journeyapps-labs/reactor-mod';
+export interface AbstractQueryEncoded {
+    type: string;
+    connection_id: string;
+    definition: string;
+}
+export declare abstract class AbstractQuery<T extends AbstractQueryEncoded = AbstractQueryEncoded> {
+    protected type: string;
+    protected connection: AbstractConnection;
+    id: string;
+    constructor(type: string, connection: AbstractConnection);
+    abstract getSimpleName(): string;
+    abstract load(): Promise<any>;
+    abstract getColumns(): TableColumn[];
+    abstract get totalPages(): number;
+    abstract getPage(number: number): Page;
+    serialize(): T;
+    deserialize(connectionStore: ConnectionStore, data: T): Promise<void>;
+}

package/dist/@types/core/query/Page.d.ts

@@ -0,0 +1,24 @@
+import { SchemaModelObject } from '../SchemaModelObject';
+import { TableRow } from '@journeyapps-labs/reactor-mod';
+import { Collection, DatabaseObject } from '@journeyapps/db';
+import { SchemaModelDefinition } from '../SchemaModelDefinition';
+export interface PageRow extends TableRow {
+    model: SchemaModelObject;
+    definition: SchemaModelDefinition;
+}
+export interface PageOptions {
+    collection: () => Promise<Collection<DatabaseObject>>;
+    offset: number;
+    limit: number;
+    definition: SchemaModelDefinition;
+    index: number;
+}
+export declare class Page {
+    protected options: PageOptions;
+    accessor models: SchemaModelObject[];
+    accessor loading: boolean;
+    constructor(options: PageOptions);
+    get index(): number;
+    load(): Promise<void>;
+    asRows(): PageRow[];
+}

package/dist/@types/core/query/SimpleQuery.d.ts

@@ -0,0 +1,36 @@
+import { AbstractQuery, AbstractQueryEncoded } from './AbstractQuery';
+import { TableColumn } from '@journeyapps-labs/reactor-mod';
+import { ConnectionStore } from '../../stores/ConnectionStore';
+import * as db from '@journeyapps/db';
+import { Promise } from '@journeyapps/db';
+import { Page, PageRow } from './Page';
+import { SchemaModelDefinition } from '../SchemaModelDefinition';
+import * as React from 'react';
+export interface SimpleQueryOptions {
+    definition?: SchemaModelDefinition;
+    limit?: number;
+}
+export interface SimpleQueryEncoded extends AbstractQueryEncoded {
+    limit: number;
+    definition: string;
+}
+export declare class SimpleQuery extends AbstractQuery<SimpleQueryEncoded> {
+    options: SimpleQueryOptions;
+    accessor connStore: ConnectionStore;
+    accessor _totalPages: number;
+    accessor _pages: Page[];
+    constructor(options?: SimpleQueryOptions);
+    getCollection(): globalThis.Promise<db.database.Collection<db.database.DatabaseObject>>;
+    load(): globalThis.Promise<void>;
+    getPage(number: number): Page;
+    get totalPages(): number;
+    serialize(): SimpleQueryEncoded;
+    deserialize(connectionStore: ConnectionStore, data: SimpleQueryEncoded): Promise<void>;
+    getColumns(): TableColumn[];
+    getSimpleName(): string;
+}
+export interface CellDisplayWidgetProps {
+    row: PageRow;
+    cell: any;
+}
+export declare const CellDisplayWidget: React.FC<CellDisplayWidgetProps>;

package/dist/@types/core/types/ManualConnection.d.ts

@@ -0,0 +1,14 @@
+import { ApiCredentialOptions, Database } from '@journeyapps/db';
+import { AbstractConnection } from '../AbstractConnection';
+import { ManualConnectionFactory } from './ManualConnectionFactory';
+export interface ManualConnectionDetails extends ApiCredentialOptions {
+    name: string;
+}
+export declare class ManualConnection extends AbstractConnection {
+    protected options?: ManualConnectionDetails;
+    constructor(factory: ManualConnectionFactory, options?: ManualConnectionDetails);
+    getConnection(): Promise<Database>;
+    _serialize(): ManualConnectionDetails;
+    _deSerialize(data: ManualConnectionDetails): Promise<any>;
+    get name(): string;
+}

package/dist/@types/core/types/ManualConnectionFactory.d.ts

@@ -0,0 +1,9 @@
+import { AbstractConnectionFactory } from '../AbstractConnectionFactory';
+import { ManualConnection } from './ManualConnection';
+import { DialogStore2 } from '@journeyapps-labs/reactor-mod';
+export declare class ManualConnectionFactory extends AbstractConnectionFactory<ManualConnection> {
+    accessor dialogStore: DialogStore2;
+    constructor();
+    generateConnectionFromUI(): Promise<ManualConnection | null>;
+    generateConnection(): ManualConnection;
+}

package/dist/@types/entities/ConnectionEntityDefinition.d.ts

@@ -0,0 +1,9 @@
+import { EntityDefinition } from '@journeyapps-labs/reactor-mod';
+import { ConnectionStore } from '../stores/ConnectionStore';
+import { AbstractConnection } from '../core/AbstractConnection';
+export declare class ConnectionEntityDefinition extends EntityDefinition<AbstractConnection> {
+    accessor connectionStore: ConnectionStore;
+    constructor();
+    matchEntity(t: any): boolean;
+    getEntityUID(t: AbstractConnection): string;
+}

package/dist/@types/entities/ConnectionFactoryEntityDefinition.d.ts

@@ -0,0 +1,9 @@
+import { EntityDefinition } from '@journeyapps-labs/reactor-mod';
+import { ConnectionStore } from '../stores/ConnectionStore';
+import { AbstractConnectionFactory } from '../core/AbstractConnectionFactory';
+export declare class ConnectionFactoryEntityDefinition extends EntityDefinition<AbstractConnectionFactory> {
+    accessor connectionStore: ConnectionStore;
+    constructor();
+    matchEntity(t: any): boolean;
+    getEntityUID(t: AbstractConnectionFactory): string;
+}

package/dist/@types/entities/QueryEntityDefinition.d.ts

@@ -0,0 +1,9 @@
+import { EntityDefinition } from '@journeyapps-labs/reactor-mod';
+import { ConnectionStore } from '../stores/ConnectionStore';
+import { AbstractQuery } from '../core/query/AbstractQuery';
+export declare class QueryEntityDefinition extends EntityDefinition<AbstractQuery> {
+    accessor connectionStore: ConnectionStore;
+    constructor();
+    matchEntity(t: any): boolean;
+    getEntityUID(t: AbstractQuery): string;
+}

package/dist/@types/entities/SchemaModelDefinitionEntityDefinition.d.ts

@@ -0,0 +1,13 @@
+import { EntityDefinition } from '@journeyapps-labs/reactor-mod';
+import { ConnectionStore } from '../stores/ConnectionStore';
+import { SchemaModelDefinition } from '../core/SchemaModelDefinition';
+export interface SchemaModelDefinitionEntityDefinitionEncoded {
+    connection_id: string;
+    type: string;
+}
+export declare class SchemaModelDefinitionEntityDefinition extends EntityDefinition<SchemaModelDefinition> {
+    accessor connectionStore: ConnectionStore;
+    constructor();
+    matchEntity(t: any): boolean;
+    getEntityUID(t: SchemaModelDefinition): string;
+}

package/dist/@types/entities/SchemaModelObjectEntityDefinition.d.ts

@@ -0,0 +1,14 @@
+import { EntityDefinition } from '@journeyapps-labs/reactor-mod';
+import { ConnectionStore } from '../stores/ConnectionStore';
+import { SchemaModelObject } from '../core/SchemaModelObject';
+export interface SchemaModelObjectEntityDefinitionEncoded {
+    connection_id: string;
+    type: string;
+    id: string;
+}
+export declare class SchemaModelObjectEntityDefinition extends EntityDefinition<SchemaModelObject> {
+    accessor connectionStore: ConnectionStore;
+    constructor();
+    matchEntity(t: any): boolean;
+    getEntityUID(t: SchemaModelObject): string;
+}

package/dist/@types/entities.d.ts

@@ -0,0 +1,7 @@
+export declare enum DataBrowserEntities {
+    CONNECTION = "databrowser/connection",
+    CONNECTION_FACTORY = "databrowser/connection_factory",
+    SCHEMA_MODEL_DEFINITION = "databrowser/schema_model_definition",
+    SCHEMA_MODEL_OBJECT = "databrowser/schema_model_object",
+    QUERY = "databrowser/query"
+}

package/dist/@types/forms/APIConnectionForm.d.ts

@@ -0,0 +1,12 @@
+import { FormModel } from '@journeyapps-labs/reactor-mod';
+import { ManualConnection } from '../core/types/ManualConnection';
+import { ManualConnectionFactory } from '../core/types/ManualConnectionFactory';
+export interface APIConnectionFormValue {
+    name: string;
+    base_url: string;
+    api_token: string;
+}
+export declare class APIConnectionForm extends FormModel<APIConnectionFormValue> {
+    constructor(value?: APIConnectionFormValue);
+    generateConnection(factory: ManualConnectionFactory): ManualConnection;
+}

package/dist/@types/forms/SchemaModelForm.d.ts

@@ -0,0 +1,11 @@
+import { FormModel } from '@journeyapps-labs/reactor-mod';
+import { SchemaModelDefinition } from '../core/SchemaModelDefinition';
+import { SchemaModelObject } from '../core/SchemaModelObject';
+export interface SchemaModelFormOptions {
+    definition: SchemaModelDefinition;
+    object?: SchemaModelObject;
+}
+export declare class SchemaModelForm extends FormModel {
+    protected options: SchemaModelFormOptions;
+    constructor(options: SchemaModelFormOptions);
+}

package/dist/@types/index.d.ts

@@ -0,0 +1,3 @@
+import { DataBrowserModule } from './DataBrowserModule';
+export * from './entities';
+export default DataBrowserModule;

package/dist/@types/panels/model/ModelPanelFactory.d.ts

@@ -0,0 +1,28 @@
+import * as React from 'react';
+import { ReactorPanelFactory, ReactorPanelModel } from '@journeyapps-labs/reactor-mod';
+import { ConnectionStore } from '../../stores/ConnectionStore';
+import { WorkspaceModelFactoryEvent } from '@projectstorm/react-workspaces-core';
+import { SchemaModelDefinition } from '../../core/SchemaModelDefinition';
+import { SchemaModelObject } from '../../core/SchemaModelObject';
+export interface ModelPanelModelOptions {
+    definition: SchemaModelDefinition;
+    model?: SchemaModelObject;
+}
+export declare class ModelPanelModel extends ReactorPanelModel {
+    accessor connStore: ConnectionStore;
+    accessor definition: SchemaModelDefinition;
+    accessor model: SchemaModelObject;
+    constructor(options?: ModelPanelModelOptions);
+    encodeEntities(): {
+        definition: SchemaModelDefinition;
+        model: SchemaModelObject;
+    };
+    decodeEntities(data: ReturnType<this['encodeEntities']>): void;
+}
+export declare class ModelPanelFactory extends ReactorPanelFactory<ModelPanelModel> {
+    static TYPE: string;
+    constructor();
+    getSimpleName(model: ModelPanelModel): string;
+    _generateModel(): ModelPanelModel;
+    generatePanelContent(event: WorkspaceModelFactoryEvent<ModelPanelModel>): React.JSX.Element;
+}

package/dist/@types/panels/model/ModelPanelWidget.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+import { ModelPanelModel } from './ModelPanelFactory';
+export interface QueryPanelWidgetProps {
+    model: ModelPanelModel;
+}
+export declare const ModelPanelWidget: React.FC<QueryPanelWidgetProps>;

package/dist/@types/panels/query/PageResultsWidget.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+import { Page } from '../../core/query/Page';
+import { AbstractQuery } from '../../core/query/AbstractQuery';
+export interface PageResultsWidgetProps {
+    page: Page;
+    query: AbstractQuery;
+}
+export declare const PageResultsWidget: React.FC<PageResultsWidgetProps>;

package/dist/@types/panels/query/QueryPanelFactory.d.ts

@@ -0,0 +1,33 @@
+import * as React from 'react';
+import { ReactorPanelFactory, ReactorPanelModel } from '@journeyapps-labs/reactor-mod';
+import { AbstractQuery } from '../../core/query/AbstractQuery';
+import { ConnectionStore } from '../../stores/ConnectionStore';
+import { WorkspaceModelFactoryEvent } from '@projectstorm/react-workspaces-core';
+export declare class QueryPanelModel extends ReactorPanelModel {
+    accessor connStore: ConnectionStore;
+    accessor query: AbstractQuery;
+    accessor current_page: number;
+    constructor(query: AbstractQuery);
+    toArray(): {
+        current_page: number;
+        _encoded: {};
+        id: string;
+        expandVertical: boolean;
+        expandHorizontal: boolean;
+        type: string;
+        width: number;
+        height: number;
+    };
+    fromArray(data: ReturnType<this['toArray']>, engine: any): void;
+    encodeEntities(): {
+        query: AbstractQuery<import("../../core/query/AbstractQuery").AbstractQueryEncoded>;
+    };
+    decodeEntities(data: ReturnType<this['encodeEntities']>): void;
+}
+export declare class QueryPanelFactory extends ReactorPanelFactory<QueryPanelModel> {
+    static TYPE: string;
+    constructor();
+    getSimpleName(model: QueryPanelModel): string;
+    _generateModel(): QueryPanelModel;
+    generatePanelContent(event: WorkspaceModelFactoryEvent<QueryPanelModel>): React.JSX.Element;
+}

package/dist/@types/panels/query/QueryPanelWidget.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+import { QueryPanelModel } from './QueryPanelFactory';
+export interface QueryPanelWidgetProps {
+    model: QueryPanelModel;
+}
+export declare const QueryPanelWidget: React.FC<QueryPanelWidgetProps>;

package/dist/@types/panels/query/TableControlsWidget.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+import { AbstractQuery } from '../../core/query/AbstractQuery';
+import { Page } from '../../core/query/Page';
+export interface TableControlsWidgetProps {
+    current_page: Page;
+    goToPage?: (index: number) => any;
+    className?: any;
+    query: AbstractQuery;
+}
+export declare const TableControlsWidget: React.FC<TableControlsWidgetProps>;

package/dist/@types/stores/ConnectionStore.d.ts

@@ -0,0 +1,20 @@
+import { AbstractStore } from '@journeyapps-labs/reactor-mod';
+import { AbstractConnection, AbstractConnectionSerialized } from '../core/AbstractConnection';
+import { AbstractConnectionFactory } from '../core/AbstractConnectionFactory';
+export interface ConnectionStoreSerialized {
+    connections: AbstractConnectionSerialized[];
+}
+export declare class ConnectionStore extends AbstractStore<ConnectionStoreSerialized> {
+    protected accessor _connections: Set<AbstractConnection>;
+    protected _connectionFactories: Map<string, AbstractConnectionFactory>;
+    constructor();
+    get connections(): AbstractConnection[];
+    get connectionFactories(): AbstractConnectionFactory<AbstractConnection>[];
+    protected serialize(): ConnectionStoreSerialized;
+    getConnectionByID(id: string): AbstractConnection;
+    waitForReadyForConnection(id: string): Promise<AbstractConnection>;
+    deserializeConnection(data: AbstractConnectionSerialized): Promise<AbstractConnection>;
+    protected deserialize(data: ConnectionStoreSerialized): Promise<void>;
+    registerConnectionFactory(factory: AbstractConnectionFactory): void;
+    addConnection(connection: AbstractConnection): void;
+}

package/dist/DataBrowserModule.js

@@ -0,0 +1,45 @@
+import { AbstractReactorModule, System, WorkspaceStore } from '@journeyapps-labs/reactor-mod';
+import { ConnectionStore } from './stores/ConnectionStore';
+import { ConnectionEntityDefinition } from './entities/ConnectionEntityDefinition';
+import { ManualConnectionFactory } from './core/types/ManualConnectionFactory';
+import { ConnectionFactoryEntityDefinition } from './entities/ConnectionFactoryEntityDefinition';
+import { AddConnectionAction } from './actions/connections/AddConnectionAction';
+import { RemoveConnectionAction } from './actions/connections/RemoveConnectionAction';
+import { SchemaModelDefinitionEntityDefinition } from './entities/SchemaModelDefinitionEntityDefinition';
+import { QueryPanelFactory } from './panels/query/QueryPanelFactory';
+import { QuerySchemaModelAction } from './actions/schema-definitions/QuerySchemaModelAction';
+import { QueryEntityDefinition } from './entities/QueryEntityDefinition';
+import { ModelPanelFactory } from './panels/model/ModelPanelFactory';
+import { CreateModelAction } from './actions/schema-definitions/CreateModelAction';
+import { SchemaModelObjectEntityDefinition } from './entities/SchemaModelObjectEntityDefinition';
+import { EditSchemaModelAction } from './actions/schema-model/EditSchemaModelAction';
+export class DataBrowserModule extends AbstractReactorModule {
+    constructor() {
+        super({
+            name: 'Data Browser'
+        });
+    }
+    register(ioc) {
+        const system = ioc.get(System);
+        const workspaceStore = ioc.get(WorkspaceStore);
+        let connectionStore = new ConnectionStore();
+        connectionStore.registerConnectionFactory(new ManualConnectionFactory());
+        system.registerAction(new AddConnectionAction());
+        system.registerAction(new RemoveConnectionAction());
+        system.registerAction(new QuerySchemaModelAction());
+        system.registerAction(new CreateModelAction());
+        system.registerAction(new EditSchemaModelAction());
+        system.addStore(ConnectionStore, connectionStore);
+        system.registerDefinition(new ConnectionEntityDefinition());
+        system.registerDefinition(new ConnectionFactoryEntityDefinition());
+        system.registerDefinition(new SchemaModelDefinitionEntityDefinition());
+        system.registerDefinition(new SchemaModelObjectEntityDefinition());
+        system.registerDefinition(new QueryEntityDefinition());
+        workspaceStore.registerFactory(new QueryPanelFactory());
+        workspaceStore.registerFactory(new ModelPanelFactory());
+    }
+    async init(ioc) {
+        await ioc.get(ConnectionStore).init();
+    }
+}
+//# sourceMappingURL=DataBrowserModule.js.map

package/dist/DataBrowserModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DataBrowserModule.js","sourceRoot":"","sources":["../src/DataBrowserModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAE9F,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,0BAA0B,EAAE,MAAM,uCAAuC,CAAC;AACnF,OAAO,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAC/E,OAAO,EAAE,iCAAiC,EAAE,MAAM,8CAA8C,CAAC;AACjG,OAAO,EAAE,mBAAmB,EAAE,MAAM,2CAA2C,CAAC;AAChF,OAAO,EAAE,sBAAsB,EAAE,MAAM,8CAA8C,CAAC;AACtF,OAAO,EAAE,qCAAqC,EAAE,MAAM,kDAAkD,CAAC;AACzG,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,EAAE,sBAAsB,EAAE,MAAM,qDAAqD,CAAC;AAC7F,OAAO,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,EAAE,iBAAiB,EAAE,MAAM,gDAAgD,CAAC;AACnF,OAAO,EAAE,iCAAiC,EAAE,MAAM,8CAA8C,CAAC;AACjG,OAAO,EAAE,qBAAqB,EAAE,MAAM,8CAA8C,CAAC;AAErF,MAAM,OAAO,iBAAkB,SAAQ,qBAAqB;IAC1D;QACE,KAAK,CAAC;YACJ,IAAI,EAAE,cAAc;SACrB,CAAC,CAAC;IACL,CAAC;IAED,QAAQ,CAAC,GAAc;QACrB,MAAM,MAAM,GAAG,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAC/B,MAAM,cAAc,GAAG,GAAG,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;QAE/C,IAAI,eAAe,GAAG,IAAI,eAAe,EAAE,CAAC;QAE5C,eAAe,CAAC,yBAAyB,CAAC,IAAI,uBAAuB,EAAE,CAAC,CAAC;QAEzE,MAAM,CAAC,cAAc,CAAC,IAAI,mBAAmB,EAAE,CAAC,CAAC;QACjD,MAAM,CAAC,cAAc,CAAC,IAAI,sBAAsB,EAAE,CAAC,CAAC;QACpD,MAAM,CAAC,cAAc,CAAC,IAAI,sBAAsB,EAAE,CAAC,CAAC;QACpD,MAAM,CAAC,cAAc,CAAC,IAAI,iBAAiB,EAAE,CAAC,CAAC;QAC/C,MAAM,CAAC,cAAc,CAAC,IAAI,qBAAqB,EAAE,CAAC,CAAC;QAEnD,MAAM,CAAC,QAAQ,CAAC,eAAe,EAAE,eAAe,CAAC,CAAC;QAElD,MAAM,CAAC,kBAAkB,CAAC,IAAI,0BAA0B,EAAE,CAAC,CAAC;QAC5D,MAAM,CAAC,kBAAkB,CAAC,IAAI,iCAAiC,EAAE,CAAC,CAAC;QACnE,MAAM,CAAC,kBAAkB,CAAC,IAAI,qCAAqC,EAAE,CAAC,CAAC;QACvE,MAAM,CAAC,kBAAkB,CAAC,IAAI,iCAAiC,EAAE,CAAC,CAAC;QACnE,MAAM,CAAC,kBAAkB,CAAC,IAAI,qBAAqB,EAAE,CAAC,CAAC;QAEvD,cAAc,CAAC,eAAe,CAAC,IAAI,iBAAiB,EAAE,CAAC,CAAC;QACxD,cAAc,CAAC,eAAe,CAAC,IAAI,iBAAiB,EAAE,CAAC,CAAC;IAC1D,CAAC;IAED,KAAK,CAAC,IAAI,CAAC,GAAc;QACvB,MAAM,GAAG,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC,IAAI,EAAE,CAAC;IACxC,CAAC;CACF"}

package/dist/actions/connections/AddConnectionAction.js

@@ -0,0 +1,48 @@
+import { __classPrivateFieldGet, __classPrivateFieldSet, __esDecorate, __runInitializers } from "tslib";
+import { EntityAction, inject, ioc, System } from '@journeyapps-labs/reactor-mod';
+import { DataBrowserEntities } from '../../entities';
+import { ConnectionStore } from '../../stores/ConnectionStore';
+let AddConnectionAction = (() => {
+    var _a, _AddConnectionAction_connectionStore_accessor_storage;
+    let _classSuper = EntityAction;
+    let _connectionStore_decorators;
+    let _connectionStore_initializers = [];
+    let _connectionStore_extraInitializers = [];
+    return _a = class AddConnectionAction extends _classSuper {
+            get connectionStore() { return __classPrivateFieldGet(this, _AddConnectionAction_connectionStore_accessor_storage, "f"); }
+            set connectionStore(value) { __classPrivateFieldSet(this, _AddConnectionAction_connectionStore_accessor_storage, value, "f"); }
+            constructor() {
+                super({
+                    id: _a.ID,
+                    name: 'Add connection',
+                    icon: 'plus',
+                    target: DataBrowserEntities.CONNECTION_FACTORY,
+                    autoSelectIsolatedTarget: true
+                });
+                _AddConnectionAction_connectionStore_accessor_storage.set(this, __runInitializers(this, _connectionStore_initializers, void 0));
+                __runInitializers(this, _connectionStore_extraInitializers);
+            }
+            async fireEvent(event) {
+                let connection = await event.targetEntity.generateConnectionFromUI();
+                if (!connection) {
+                    return;
+                }
+                this.connectionStore.addConnection(connection);
+            }
+            static get() {
+                return ioc.get(System).getActionByID(_a.ID);
+            }
+        },
+        _AddConnectionAction_connectionStore_accessor_storage = new WeakMap(),
+        (() => {
+            var _b;
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create((_b = _classSuper[Symbol.metadata]) !== null && _b !== void 0 ? _b : null) : void 0;
+            _connectionStore_decorators = [inject(ConnectionStore)];
+            __esDecorate(_a, null, _connectionStore_decorators, { kind: "accessor", name: "connectionStore", static: false, private: false, access: { has: obj => "connectionStore" in obj, get: obj => obj.connectionStore, set: (obj, value) => { obj.connectionStore = value; } }, metadata: _metadata }, _connectionStore_initializers, _connectionStore_extraInitializers);
+            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        })(),
+        _a.ID = 'ADD_CONNECTION',
+        _a;
+})();
+export { AddConnectionAction };
+//# sourceMappingURL=AddConnectionAction.js.map

package/dist/actions/connections/AddConnectionAction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AddConnectionAction.js","sourceRoot":"","sources":["../../../src/actions/connections/AddConnectionAction.tsx"],"names":[],"mappings":";AAAA,OAAO,EAAE,YAAY,EAAqB,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,+BAA+B,CAAC;AAErG,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;IAElD,mBAAmB;;sBAAS,YAAY;;;;sBAAxC,mBAAoB,SAAQ,WAAuC;YAI9E,IAAS,eAAe,uGAAkB;YAA1C,IAAS,eAAe,4GAAkB;YAE1C;gBACE,KAAK,CAAC;oBACJ,EAAE,EAAE,EAAmB,CAAC,EAAE;oBAC1B,IAAI,EAAE,gBAAgB;oBACtB,IAAI,EAAE,MAAM;oBACZ,MAAM,EAAE,mBAAmB,CAAC,kBAAkB;oBAC9C,wBAAwB,EAAE,IAAI;iBAC/B,CAAC,CAAC;gBATI,gIAAiC;;aAUzC;YAED,KAAK,CAAC,SAAS,CAAC,KAAmD;gBACjE,IAAI,UAAU,GAAG,MAAM,KAAK,CAAC,YAAY,CAAC,wBAAwB,EAAE,CAAC;gBACrE,IAAI,CAAC,UAAU,EAAE,CAAC;oBAChB,OAAO;gBACT,CAAC;gBACD,IAAI,CAAC,eAAe,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;YACjD,CAAC;YAED,MAAM,CAAC,GAAG;gBACR,OAAO,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,aAAa,CAAsB,EAAmB,CAAC,EAAE,CAAC,CAAC;YACpF,CAAC;;;;;;2CAvBA,MAAM,CAAC,eAAe,CAAC;YACxB,gMAAS,eAAe,6BAAf,eAAe,yGAAkB;;;QAHnC,KAAE,GAAG,gBAAiB;;;SADlB,mBAAmB"}