@treelab/treelab/build/client.js

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
const debug = require("debug");
const rxjs_1 = require("rxjs");
const Ops = require("rxjs/operators");
const rxmq_1 = require("rxmq");
const service_pb_1 = require("./proto/service_pb");
const log = debug('treelab-ts-sdk:client');
class Client {
    constructor(client, metadata) {
        this._serviceClient = client;
        this._metadata = metadata;
    }
    unaryCall(call, request) {
        return new Promise((resolve, reject) => {
            call(request, (error, response) => {
                if (error) {
                    return reject(error);
                }
                resolve(response);
            });
        });
    }
    createWorkspaceInput(obj) {
        const createWorkspaceInput = new service_pb_1.CreateWorkspaceInput();
        createWorkspaceInput.setName(obj.name);
        return createWorkspaceInput;
    }
    addCoreInput(obj) {
        const addCoreInput = new service_pb_1.AddCoreInput();
        addCoreInput.setWorkspaceid(obj.workspaceid);
        addCoreInput.setCorename(obj.corename);
        addCoreInput.setColor(obj.color);
        addCoreInput.setIcon(obj.icon);
        return addCoreInput;
    }
    updateCoreInput(obj) {
        const updateCoreInput = new service_pb_1.UpdateCoreInput();
        updateCoreInput.setWorkspaceid(obj.workspaceid);
        updateCoreInput.setCoreid(obj.coreid);
        updateCoreInput.setCorename(obj.corename);
        updateCoreInput.setColor(obj.color);
        updateCoreInput.setIcon(obj.icon);
        return updateCoreInput;
    }
    addTableInput(obj) {
        const addTableInput = new service_pb_1.AddTableInput();
        addTableInput.setWorkspaceid(obj.workspaceid);
        addTableInput.setCoreid(obj.coreid);
        addTableInput.setTablename(obj.tablename);
        return addTableInput;
    }
    viewDefinitionInput(obj) {
        const viewDefinitionInput = new service_pb_1.ViewDefinitionInput();
        viewDefinitionInput.setName(obj.name);
        viewDefinitionInput.setType(obj.type);
        return viewDefinitionInput;
    }
    addViewInput(obj) {
        const addViewInput = new service_pb_1.AddViewInput();
        addViewInput.setWorkspaceid(obj.workspaceid);
        addViewInput.setCoreid(obj.coreid);
        addViewInput.setTableid(obj.tableid);
        addViewInput.setView(this.viewDefinitionInput(obj.view));
        return addViewInput;
    }
    choiceInput(obj) {
        const choice = new service_pb_1.Choice();
        if (!obj)
            return choice;
        choice.setId(obj.id);
        choice.setColor(obj.color);
        choice.setName(obj.name);
        return choice;
    }
    columnConfigInput(obj) {
        const columnConfig = new service_pb_1.ColumnConfigInput();
        columnConfig.setType(obj.type);
        columnConfig.setName(obj.name);
        columnConfig.setOrder(obj.order);
        columnConfig.setForeigntableid(obj.foreigntableid);
        columnConfig.setDefaultnumber(obj.defaultnumber);
        columnConfig.setPrecision(obj.precision);
        columnConfig.setChoicesList(obj.choicesList ? obj.choicesList.map(i => this.choiceInput(i)) : []);
        return columnConfig;
    }
    addColumnInput(obj) {
        const addColumnInput = new service_pb_1.AddColumnInput();
        addColumnInput.setWorkspaceid(obj.workspaceid);
        addColumnInput.setCoreid(obj.coreid);
        addColumnInput.setTableid(obj.tableid);
        addColumnInput.setColumnconfig(this.columnConfigInput(obj.columnconfig));
        return addColumnInput;
    }
    addRowInput(obj) {
        const addRowInput = new service_pb_1.AddRowInput();
        addRowInput.setWorkspaceid(obj.workspaceid);
        addRowInput.setCoreid(obj.coreid);
        addRowInput.setTableid(obj.tableid);
        return addRowInput;
    }
    foreignRowVisibleNameValue(obj) {
        const foreignRowVisibleNameValue = new service_pb_1.ForeignRowVisibleNameValue();
        foreignRowVisibleNameValue.setValue(obj.value);
        return foreignRowVisibleNameValue;
    }
    foreignRowValue(obj) {
        const foreignRowValue = new service_pb_1.ForeignRowValue();
        foreignRowValue.setId(obj.id);
        foreignRowValue.setVisiblenameList(obj.visiblenameList.map(i => this.foreignRowVisibleNameValue(i)));
        return foreignRowValue;
    }
    attachment(obj) {
        const attachment = new service_pb_1.Attachment();
        attachment.setName(obj.name);
        attachment.setUrl(obj.url);
        return attachment;
    }
    cellData(obj) {
        const cellData = new service_pb_1.CellData();
        cellData.setColumnid(obj.columnid);
        cellData.setType(obj.type);
        if (obj.text)
            cellData.setText(obj.text);
        if (obj.foreignrowList)
            cellData.setForeignrowList(obj.foreignrowList.map(i => this.foreignRowValue(i)));
        if (obj.number)
            cellData.setNumber(obj.number);
        // TODO string for now
        if (obj.selecteditems)
            cellData.setSelecteditems(obj.selecteditems);
        if (obj.selecteditem)
            cellData.setSelecteditem(obj.selecteditem);
        if (obj.attachments)
            cellData.setAttachments(obj.attachments);
        // if (obj.selecteditemsList)
        //   cellData.setSelecteditemsList(obj.selecteditemsList.map(i => this.choiceInput(i)));
        // if (obj.selecteditem) cellData.setSelecteditem(this.choiceInput(obj.selecteditem));
        // if (obj.attachmentsList)
        //   cellData.setAttachmentsList(obj.attachmentsList.map(i => this.attachment(i)));
        if (obj.datetime)
            cellData.setDatetime(obj.datetime);
        return cellData;
    }
    cellValueInput(obj) {
        const cellValueInput = new service_pb_1.CellValueInput();
        cellValueInput.setType(obj.type);
        if (obj.text)
            cellValueInput.setText(obj.text);
        if (obj.foreignrowid)
            cellValueInput.setForeignrowid(obj.foreignrowid);
        if (obj.number)
            cellValueInput.setNumber(obj.number);
        if (obj.selecteditem)
            cellValueInput.setSelecteditem(this.choiceInput(obj.selecteditem));
        if (obj.selecteditemsList)
            cellValueInput.setSelecteditemsList(obj.selecteditemsList.map(i => this.choiceInput(i)));
        if (obj.attachmentsList)
            cellValueInput.setAttachmentsList(obj.attachmentsList.map(i => this.attachment(i)));
        if (obj.datetime)
            cellValueInput.setDatetime(obj.datetime);
        return cellValueInput;
    }
    updateCellInput(obj) {
        const updateCellInput = new service_pb_1.UpdateCellInput();
        updateCellInput.setWorkspaceid(obj.workspaceid);
        updateCellInput.setCoreid(obj.coreid);
        updateCellInput.setTableid(obj.tableid);
        updateCellInput.setColumnid(obj.columnid);
        updateCellInput.setRowid(obj.rowid);
        updateCellInput.setAction(this.updateCellActionInput(obj.action));
        return updateCellInput;
    }
    updateCellActionInput(obj) {
        const updateCellActionInput = new service_pb_1.UpdateCellActionInput();
        updateCellActionInput.setType(obj.type);
        updateCellActionInput.setValue(this.cellValueInput(obj.value));
        return updateCellActionInput;
    }
    workspaceSubscriptionInput(obj) {
        const workspaceSubscriptionInput = new service_pb_1.WorkspaceSubscriptionInput();
        workspaceSubscriptionInput.setWorkspaceid(obj.workspaceid);
        workspaceSubscriptionInput.setTopic(obj.topic);
        return workspaceSubscriptionInput;
    }
    getTableInput(obj) {
        const getTableInput = new service_pb_1.GetTableInput();
        getTableInput.setWorkspaceid(obj.workspaceid);
        getTableInput.setCoreid(obj.coreid);
        getTableInput.setTableid(obj.tableid);
        return getTableInput;
    }
    getWorkspaceInput(obj) {
        const getWorkspaceInput = new service_pb_1.GetWorkspaceInput();
        getWorkspaceInput.setId(obj.id);
        return getWorkspaceInput;
    }
    getCoreInput(obj) {
        const getCoreInput = new service_pb_1.GetCoreInput();
        getCoreInput.setWorkspaceid(obj.workspaceid);
        getCoreInput.setCoreid(obj.coreid);
        return getCoreInput;
    }
    getCoresInput(obj) {
        const getCoresInput = new service_pb_1.GetCoresInput();
        getCoresInput.setWorkspaceid(obj.workspaceid);
        return getCoresInput;
    }
    getTablesInput(obj) {
        const getTablesInput = new service_pb_1.GetTablesInput();
        getTablesInput.setWorkspaceid(obj.workspaceid);
        getTablesInput.setCoreid(obj.coreid);
        return getTablesInput;
    }
    createWorkspace(input) {
        return __awaiter(this, void 0, void 0, function* () {
            return new Promise((resolve, reject) => {
                this._serviceClient.createWorkspace(input, this._metadata, (err, result) => {
                    if (err) {
                        return reject(err);
                    }
                    resolve(result);
                });
            });
        });
    }
    addCore(input) {
        return __awaiter(this, void 0, void 0, function* () {
            return new Promise((resolve, reject) => {
                this._serviceClient.addCore(input, this._metadata, (err, result) => {
                    if (err) {
                        return reject(err);
                    }
                    resolve(result);
                });
            });
        });
    }
    updateCore(input) {
        return __awaiter(this, void 0, void 0, function* () {
            return new Promise((resolve, reject) => {
                this._serviceClient.updateCore(input, this._metadata, (err, result) => {
                    if (err) {
                        return reject(err);
                    }
                    resolve(result);
                });
            });
        });
    }
    addTable(input) {
        return __awaiter(this, void 0, void 0, function* () {
            return new Promise((resolve, reject) => {
                this._serviceClient.addTable(input, this._metadata, (err, result) => {
                    if (err) {
                        return reject(err);
                    }
                    resolve(result);
                });
            });
        });
    }
    addView(input) {
        return __awaiter(this, void 0, void 0, function* () {
            return new Promise((resolve, reject) => {
                this._serviceClient.addView(input, (err, result) => {
                    if (err) {
                        return reject(err);
                    }
                    resolve(result);
                });
            });
        });
    }
    addColumn(input) {
        return __awaiter(this, void 0, void 0, function* () {
            return new Promise((resolve, reject) => {
                this._serviceClient.addColumn(input, this._metadata, (err, result) => {
                    if (err) {
                        return reject(err);
                    }
                    resolve(result);
                });
            });
        });
    }
    addRow(input) {
        return __awaiter(this, void 0, void 0, function* () {
            return new Promise((resolve, reject) => {
                this._serviceClient.addRow(input, this._metadata, (err, result) => {
                    if (err) {
                        return reject(err);
                    }
                    resolve(result);
                });
            });
        });
    }
    updateCell(input) {
        return __awaiter(this, void 0, void 0, function* () {
            return new Promise((resolve, reject) => {
                this._serviceClient.updateCell(input, this._metadata, (err, result) => {
                    if (err) {
                        return reject(err);
                    }
                    resolve(result);
                });
            });
        });
    }
    getWorkspaces() {
        return __awaiter(this, void 0, void 0, function* () {
            const input = new service_pb_1.EmptyInput();
            return new Promise((resolve, reject) => {
                this._serviceClient.getAllWorkspaces(input, this._metadata, (err, result) => {
                    if (err) {
                        return reject(err);
                    }
                    resolve(result);
                });
            });
        });
    }
    getWorkspace(input) {
        return __awaiter(this, void 0, void 0, function* () {
            return new Promise((resolve, reject) => {
                this._serviceClient.getWorkspace(input, this._metadata, (err, result) => {
                    if (err) {
                        return reject(err);
                    }
                    resolve(result);
                });
            });
        });
    }
    getCore(input) {
        return __awaiter(this, void 0, void 0, function* () {
            return new Promise((resolve, reject) => {
                this._serviceClient.getCore(input, this._metadata, (err, result) => {
                    if (err) {
                        return reject(err);
                    }
                    resolve(result);
                });
            });
        });
    }
    getCores(input) {
        return __awaiter(this, void 0, void 0, function* () {
            return new Promise((resolve, reject) => {
                this._serviceClient.getAllCores(input, this._metadata, (err, result) => {
                    if (err) {
                        return reject(err);
                    }
                    resolve(result);
                });
            });
        });
    }
    getTable(input) {
        return __awaiter(this, void 0, void 0, function* () {
            return new Promise((resolve, reject) => {
                this._serviceClient.getTable(input, this._metadata, (err, result) => {
                    if (err) {
                        return reject(err);
                    }
                    resolve(result);
                });
            });
        });
    }
    getTables(input) {
        return __awaiter(this, void 0, void 0, function* () {
            return new Promise((resolve, reject) => {
                this._serviceClient.getAllTables(input, this._metadata, (err, result) => {
                    if (err) {
                        return reject(err);
                    }
                    resolve(result);
                });
            });
        });
    }
    subscribeToWorkspace(input) {
        return new rxjs_1.Observable((observer) => {
            log(`opening stream for subscription ${input.toString()}`);
            const stream = this._serviceClient.subscribeToWorkspace(input, this._metadata);
            stream.on('data', (eventPayload) => {
                if (observer.closed) {
                    return;
                }
                observer.next(eventPayload);
            });
            stream.on('error', err => observer.error(err));
            stream.on('end', () => observer.complete());
            return () => {
                log(`closing stream for subscription ${input.toString()}`);
                stream.cancel();
            };
        });
    }
    observeEvent(workspaceId, topic) {
        return rxmq_1.default.channel(workspaceId).observe(topic);
    }
    observeSpecifiedEvent({ workspaceId, coreId, tableId, rowId, columnId }, specifiedTopic) {
        return this.observeEvent(workspaceId, '').pipe(Ops.filter((e) => {
            if (!coreId)
                return e.eventname.endsWith(specifiedTopic);
            if (!tableId)
                return e.eventname.startsWith(coreId) && e.eventname.endsWith(specifiedTopic);
            return (e.eventname.startsWith(`${coreId}.${tableId}`) &&
                (rowId ? e.rowid === rowId : true) &&
                (columnId ? e.columnid === columnId : true) &&
                e.eventname.endsWith(specifiedTopic));
        }));
    }
}
exports.Client = Client;
//# sourceMappingURL=client.js.map