@narwhal/data-engine-core/dist/container.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
require("reflect-metadata");
const inversify_1 = require("inversify");
const mobx_1 = require("mobx");
const mobx_utils_1 = require("mobx-utils");
const rxdb_1 = require("rxdb");
const ajv_validate_1 = require("rxdb/plugins/ajv-validate");
const rxjs_1 = require("rxjs");
const rxjs_2 = require("rxjs");
const operators_1 = require("rxjs/operators");
const util_1 = require("util");
const NarwhalSchema_1 = require("./data_engine/NarwhalSchema");
const schema_parser_1 = require("./data_engine/schema_parser");
const proxied_collection_1 = require("./data_engine/proxied_collection");
const predicate_parser_1 = require("./predicate_parser");
const TYPES_1 = require("./TYPES");
class DataEngineDatabaseContainer {
    init(db) {
        return tslib_1.__awaiter(this, void 0, void 0, function* () {
            if (db) {
                this.db = db;
            }
            else {
            }
        });
    }
}
exports.DataEngineDatabaseContainer = DataEngineDatabaseContainer;
let EmptyContext = class EmptyContext {
    context() {
        return {};
    }
};
EmptyContext = tslib_1.__decorate([
    inversify_1.injectable()
], EmptyContext);
exports.EmptyContext = EmptyContext;
let SchemaNamespaceHandlerHook = class SchemaNamespaceHandlerHook {
    handleNamespace(name, version, namespace) {
        Object.entries(namespace.schema).forEach(([schemaName, schema]) => {
            this.context.addSchema(name, version, schemaName, schema);
        });
    }
};
tslib_1.__decorate([
    inversify_1.inject(TYPES_1.CORE_TYPES.NarwhalSchemaContext),
    tslib_1.__metadata("design:type", schema_parser_1.NarwhalSchemaContext)
], SchemaNamespaceHandlerHook.prototype, "context", void 0);
SchemaNamespaceHandlerHook = tslib_1.__decorate([
    inversify_1.injectable()
], SchemaNamespaceHandlerHook);
let NamespaceHandler = class NamespaceHandler {
    addNamespace(namespace_name, namespace, version = 0) {
        for (const hook of this.hooks) {
            hook.handleNamespace(namespace_name, version, namespace);
        }
    }
};
tslib_1.__decorate([
    inversify_1.multiInject(TYPES_1.CORE_TYPES.NamespaceHandlerHook),
    tslib_1.__metadata("design:type", Array)
], NamespaceHandler.prototype, "hooks", void 0);
NamespaceHandler = tslib_1.__decorate([
    inversify_1.injectable()
], NamespaceHandler);
exports.NamespaceHandler = NamespaceHandler;
const getStream = (query) => {
    return query.$.pipe(operators_1.distinctUntilChanged((left, right) => {
        if (util_1.isArray(left) && util_1.isArray(right)) {
            const left_gids = left.map(leftEl => leftEl._rev);
            const right_gids = right.map(rightEl => rightEl._rev);
            return left_gids.every((v, i) => v === right_gids[i]) && right_gids.every((v, i) => v === left_gids[i]);
        }
        else if (left == null || right == null) {
            return left === right;
        }
        else {
            return left._rev === right._rev;
        }
    }), operators_1.map(val => {
        try {
            if (val && !val.query) {
                Object.defineProperty(val, "query", {
                    value: query,
                    enumerable: false,
                    writable: false,
                });
            }
        }
        catch (e) {
            console.warn(e);
        }
        return val;
    }));
};
exports.container_module_generator = (db) => {
    // Setup plugins here
    function annotateQuery(query) {
        if (!query.hasOwnProperty("results")) {
            // @ts-ignore
            if (query.op === "find") {
                // We don't need to cache because queries are already cached
                const mutableMap = mobx_1.observable.array([], { deep: false });
                if (!mutableMap.hasOwnProperty("unresolved")) {
                    Object.defineProperty(mutableMap, "unresolved", {
                        get() {
                            // this. atom.reportObserved();
                            // return this.unresolved;
                            const atom = mobx_1.getAtom(this);
                            atom.reportObserved();
                            // @ts-ignore
                            return this._unresolved;
                        },
                        set(val) {
                            // @ts-ignore
                            this._unresolved = val;
                            const atom = mobx_1.getAtom(this);
                            atom.reportChanged();
                        },
                    });
                }
                // @ts-ignore
                mutableMap.unresolved = true;
                // @ts-ignore
                mutableMap.query = query;
                /*
                // @ts-ignore
                            if(query.op !== "findOne" && newVal === null) {
                                return;
                            }
                */
                let qSub;
                const qStream = getStream(query);
                mobx_1.onBecomeObserved(mutableMap, () => {
                    qSub = qStream.subscribe({
                        next(arr) {
                            if (arr.length !== mutableMap.length || !mutableMap.every((v, i) => arr[i] === v)) {
                                mutableMap.splice(0, arr.length, ...arr);
                            }
                            // @ts-ignore
                            mutableMap.unresolved = false;
                        },
                    });
                });
                mobx_1.onBecomeUnobserved(mutableMap, () => {
                    if (qSub) {
                        qSub.unsubscribe();
                    }
                    qSub = null;
                });
                // @ts-ignore
                mobx_1.extendObservable(query, { results: mutableMap });
            }
            else if (query.op === "findOne") {
                const orig = {
                    unresolved: true,
                    query,
                };
                let sub;
                const stream = rxjs_1.merge(getStream(query), rxjs_2.from(query.exec()));
                const observableResource = mobx_utils_1.fromResource(callback => {
                    sub = stream.subscribe(callback);
                }, () => {
                    sub.unsubscribe();
                }, orig);
                mobx_1.extendObservable(query, {
                    get results() {
                        return observableResource.current();
                    },
                    enumerable: true,
                });
            }
        }
        // @ts-ignore
        const old_clone = query._clone.bind(query);
        function _clone(...args) {
            const res = old_clone(...args);
            annotateQuery(res);
            return res;
        }
        // @ts-ignore
        query._clone = _clone.bind(query);
    }
    rxdb_1.default.plugin({
        rxdb: true,
        hooks: {
            createRxQuery: (query) => {
                annotateQuery(query);
            },
        },
    });
    rxdb_1.default.plugin(ajv_validate_1.default);
    return new inversify_1.ContainerModule((bind) => {
        bind(TYPES_1.CORE_TYPES.PredicateParser).to(predicate_parser_1.PredicateParser).inSingletonScope();
        bind(TYPES_1.CORE_TYPES.NarwhalSchemaContext).to(schema_parser_1.NarwhalSchemaContext).inSingletonScope();
        bind(TYPES_1.CORE_TYPES.NamespaceHandler).to(NamespaceHandler).inSingletonScope();
        bind(TYPES_1.CORE_TYPES.NamespaceHandlerHook).to(SchemaNamespaceHandlerHook);
        bind(TYPES_1.CORE_TYPES.SystemContextComponent).to(EmptyContext).inSingletonScope();
        bind(TYPES_1.CORE_TYPES.NarwhalSchema).to(NarwhalSchema_1.NarwhalSchema);
        bind(TYPES_1.CORE_TYPES.NarwhalSchemaFactory).toAutoFactory(TYPES_1.CORE_TYPES.NarwhalSchema);
        bind(TYPES_1.CORE_TYPES.DataEngineDatabase).toConstantValue(db);
        bind(TYPES_1.CORE_TYPES.ConcreteProxiedCollection).to(proxied_collection_1.ConcreteProxiedCollection);
        bind(TYPES_1.CORE_TYPES.ProxiedCollection).to(proxied_collection_1.ProxiedCollection);
        bind(TYPES_1.CORE_TYPES.ProxiedCollectionFactory).toAutoFactory(TYPES_1.CORE_TYPES.ProxiedCollection);
        bind(TYPES_1.CORE_TYPES.ConcreteProxiedCollectionFactory).toFactory(context => (schema, collection) => {
            const proxied_collection = context.container.get(TYPES_1.CORE_TYPES.ConcreteProxiedCollection);
            proxied_collection.init(schema, collection);
            return proxied_collection;
        });
    });
};
//# sourceMappingURL=container.js.map