@quatrain/core 1.0.0-beta24 → 1.0.0-beta26

package/lib/backends/BackendError.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BackendError = void 0;
-class BackendError extends Error {
-}
-exports.BackendError = BackendError;

package/lib/backends/Filter.d.ts

@@ -1,17 +0,0 @@
-import { BaseObjectCore } from '../components';
-import { FilterOperatorType } from './FilterOperators';
-export type FilterValueType<T extends BaseObjectCore> = T | number | string | string[] | null;
-export interface FilterType {
-    prop: string;
-    operator: FilterOperatorType | undefined;
-    value: FilterValueType<any>;
-}
-/**
- * Filter object
- */
-export declare class Filter implements FilterType {
-    prop: string;
-    operator: FilterOperatorType;
-    value: FilterValueType<any>;
-    constructor(prop: string, value: FilterValueType<any>, operator?: FilterOperatorType);
-}

package/lib/backends/Filter.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Filter = void 0;
-/**
- * Filter object
- */
-class Filter {
-    constructor(prop, value, operator = 'equals') {
-        this.prop = prop;
-        this.operator = operator;
-        this.value = value;
-    }
-}
-exports.Filter = Filter;

package/lib/backends/FilterOperators.d.ts

@@ -1,13 +0,0 @@
-export declare enum FilterOperator {
-    equals = 0,
-    notEquals = 1,
-    greater = 2,
-    greaterOrEquals = 3,
-    lower = 4,
-    lowerOrEquals = 5,
-    contains = 6,
-    notContains = 7,
-    containsAll = 8,
-    containsAny = 9
-}
-export type FilterOperatorType = 'equals' | 'notEquals' | 'greater' | 'greaterOrEquals' | 'lower' | 'lowerOrEquals' | 'contains' | 'notContains' | 'containsAll' | 'containsAny';

package/lib/backends/FilterOperators.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FilterOperator = void 0;
-var FilterOperator;
-(function (FilterOperator) {
-    FilterOperator[FilterOperator["equals"] = 0] = "equals";
-    FilterOperator[FilterOperator["notEquals"] = 1] = "notEquals";
-    FilterOperator[FilterOperator["greater"] = 2] = "greater";
-    FilterOperator[FilterOperator["greaterOrEquals"] = 3] = "greaterOrEquals";
-    FilterOperator[FilterOperator["lower"] = 4] = "lower";
-    FilterOperator[FilterOperator["lowerOrEquals"] = 5] = "lowerOrEquals";
-    FilterOperator[FilterOperator["contains"] = 6] = "contains";
-    FilterOperator[FilterOperator["notContains"] = 7] = "notContains";
-    FilterOperator[FilterOperator["containsAll"] = 8] = "containsAll";
-    FilterOperator[FilterOperator["containsAny"] = 9] = "containsAny";
-})(FilterOperator || (exports.FilterOperator = FilterOperator = {}));

package/lib/backends/Filters.d.ts

@@ -1,11 +0,0 @@
-import { Filter } from './Filter';
-export interface FiltersType {
-    or?: Filter[];
-    and?: Filter[];
-    base?: string;
-}
-export declare class Filters implements FiltersType {
-    or?: Filter[];
-    and?: Filter[];
-    constructor(or?: Filter[], and?: Filter[]);
-}

package/lib/backends/Filters.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Filters = void 0;
-class Filters {
-    constructor(or, and) {
-        if (or) {
-            this.or = or;
-        }
-        if (and) {
-            this.and = and;
-        }
-    }
-}
-exports.Filters = Filters;

package/lib/backends/Limits.d.ts

@@ -1,9 +0,0 @@
-export interface LimitsType {
-    offset: number;
-    batch: number;
-}
-export declare class Limits implements LimitsType {
-    offset: number;
-    batch: number;
-    constructor(offset?: number, batch?: number);
-}

package/lib/backends/Limits.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Limits = void 0;
-class Limits {
-    constructor(offset = 0, batch = 10) {
-        this.offset = offset;
-        this.batch = batch;
-    }
-}
-exports.Limits = Limits;

package/lib/backends/MockAdapter.d.ts

@@ -1,25 +0,0 @@
-import { DataObjectClass } from '../components/types/DataObjectClass';
-import { QueryResultType } from './Query';
-import { Filter } from './Filter';
-import { Filters } from './Filters';
-import { SortAndLimit } from './SortAndLimit';
-import { AbstractAdapter } from './AbstractAdapter';
-import { BackendInterface } from './types/BackendInterface';
-import { BackendRecordType } from '../Backend';
-export declare class MockAdapter extends AbstractAdapter implements BackendInterface {
-    protected static _fixtures: any;
-    /**
-     * Inject fixtures data to backend adapter
-     * @param data BackendRecordType
-     */
-    static inject(data: BackendRecordType): void;
-    static dao2backend(data: BackendRecordType): Promise<any>;
-    static getFixtures(): any[];
-    static getFixture(key: string): any;
-    create(dataObject: DataObjectClass<any>): Promise<DataObjectClass<any>>;
-    read(dataObject: DataObjectClass<any>): Promise<DataObjectClass<any>>;
-    update(dataObject: DataObjectClass<any>): Promise<DataObjectClass<any>>;
-    delete(dataObject: DataObjectClass<any>): Promise<DataObjectClass<any>>;
-    deleteCollection(collection: string, batchSize?: number | undefined): Promise<void>;
-    find(dataObject: DataObjectClass<any>, filters?: Filters | Filter[] | undefined, pagination?: SortAndLimit | undefined): Promise<QueryResultType<DataObjectClass<any>>>;
-}

package/lib/backends/MockAdapter.js

@@ -1,189 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    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) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MockAdapter = void 0;
-const Core_1 = require("../Core");
-const ObjectUri_1 = require("../components/ObjectUri");
-const faker_1 = require("@faker-js/faker");
-const BackendError_1 = require("./BackendError");
-const ResourcesErrors_1 = require("../common/ResourcesErrors");
-const AbstractAdapter_1 = require("./AbstractAdapter");
-class MockAdapter extends AbstractAdapter_1.AbstractAdapter {
-    /**
-     * Inject fixtures data to backend adapter
-     * @param data BackendRecordType
-     */
-    static inject(data) {
-        if (data.path) {
-            MockAdapter._fixtures[data.path] = this.dao2backend(data);
-        }
-        else {
-            throw new Error(`Can't inject data without a path`);
-        }
-    }
-    static dao2backend(data) {
-        const processed = {};
-        Object.keys(data).forEach((key) => {
-            if (data[key] !== null &&
-                typeof data[key] === 'object' &&
-                data[key].name === 'BaseObject') {
-                processed[key] = data[key].dataObject.uri.toReference();
-            }
-            else {
-                processed[key] = data[key];
-            }
-        });
-        return processed;
-    }
-    static getFixtures() {
-        return MockAdapter._fixtures;
-    }
-    static getFixture(key) {
-        return MockAdapter._fixtures[key];
-    }
-    create(dataObject) {
-        const uri = `${this.getCollection(dataObject)}/${faker_1.faker.random.alphaNumeric(12)}`;
-        dataObject.uri = new ObjectUri_1.ObjectUri(uri);
-        return new Promise((resolve, reject) => {
-            try {
-                MockAdapter.inject(Object.assign(Object.assign({}, dataObject.toJSON()), { uid: uri, path: uri }));
-                resolve(dataObject);
-            }
-            catch (err) {
-                reject(new BackendError_1.BackendError(err.message));
-            }
-        });
-    }
-    read(dataObject) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-                const path = dataObject.path;
-                const data = MockAdapter._fixtures[path];
-                if (data === undefined) {
-                    reject(new ResourcesErrors_1.NotFoundError(`[Mock] No data for ${path}`));
-                    return;
-                }
-                this.log(`[DAO] Populating ${dataObject.path}`);
-                resolve(yield dataObject.populate(data));
-            }));
-        });
-    }
-    update(dataObject) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-                const path = dataObject.path;
-                const data = MockAdapter._fixtures[path];
-                if (data === undefined) {
-                    reject(new ResourcesErrors_1.NotFoundError(`[Mock] No data for ${path}`));
-                }
-                this.log(`[DAO] Updating ${dataObject.path}`);
-                MockAdapter._fixtures[path] = Object.assign(Object.assign({}, data), dataObject.toJSON());
-                resolve(dataObject);
-            }));
-        });
-    }
-    delete(dataObject) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => {
-                const path = dataObject.path;
-                const data = MockAdapter._fixtures[path];
-                if (data === undefined) {
-                    reject(new ResourcesErrors_1.NotFoundError(`[Mock] No data for ${path}`));
-                }
-                delete MockAdapter._fixtures[dataObject.path];
-                dataObject.uri = new ObjectUri_1.ObjectUri();
-                resolve(dataObject);
-            });
-        });
-    }
-    deleteCollection(collection, batchSize) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (let key in MockAdapter._fixtures) {
-                if (key.startsWith(`${collection}/`)) {
-                    delete MockAdapter._fixtures[key];
-                }
-            }
-            return new Promise(() => null);
-        });
-    }
-    find(dataObject, filters = undefined, pagination = undefined) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const limit = (pagination === null || pagination === void 0 ? void 0 : pagination.limits.batch) || 1e10;
-            let items = [];
-            const collection = this.getCollection(dataObject);
-            // TODO filter only records matchinf collection
-            for (let key in MockAdapter.getFixtures()) {
-                let keep = true;
-                if (key.startsWith(`${collection}/`) && items.length <= limit) {
-                    const dao = yield dataObject.clone(MockAdapter.getFixture(key));
-                    if (filters) {
-                        if (Array.isArray(filters)) {
-                            filters.forEach((filter) => {
-                                const prop = dao.get(filter.prop);
-                                if (typeof prop === 'undefined') {
-                                    keep = false;
-                                    return;
-                                }
-                                const val = prop.val();
-                                if (typeof prop === 'object') {
-                                    if (prop.constructor.name === 'ObjectProperty') {
-                                        if (filter.value instanceof ObjectUri_1.ObjectUri &&
-                                            val &&
-                                            val.ref !== filter.value.path) {
-                                            keep = false;
-                                            return;
-                                        }
-                                    }
-                                    else if (prop.constructor.name === 'CollectionProperty') {
-                                        if (filter.value instanceof ObjectUri_1.ObjectUri &&
-                                            prop.val() !== filter.value.path) {
-                                            keep = false;
-                                            return;
-                                        }
-                                    }
-                                    else if (val !== filter.value) {
-                                        keep = false;
-                                        return;
-                                    }
-                                }
-                                else {
-                                    if (prop.val() !== filter.value) {
-                                        keep = false;
-                                        return;
-                                    }
-                                }
-                            });
-                        }
-                    }
-                    if (keep) {
-                        dao.uri = new ObjectUri_1.ObjectUri(key);
-                        items.push(dao);
-                    }
-                }
-            }
-            if (pagination && pagination.sortings.length > 0) {
-                items = items.sort((a, b) => Number(a.val(pagination.sortings[0].prop) >
-                    b.val(pagination.sortings[0].prop)));
-            }
-            return {
-                items,
-                meta: {
-                    count: 100,
-                    offset: (pagination === null || pagination === void 0 ? void 0 : pagination.limits.offset) || 0,
-                    batch: (pagination === null || pagination === void 0 ? void 0 : pagination.limits.batch) || 10,
-                    executionTime: Core_1.Core.timestamp(),
-                },
-            };
-        });
-    }
-}
-exports.MockAdapter = MockAdapter;
-MockAdapter._fixtures = {};

package/lib/backends/NotFoundError.d.ts

@@ -1,2 +0,0 @@
-export declare class NotFoundError extends Error {
-}

package/lib/backends/NotFoundError.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NotFoundError = void 0;
-class NotFoundError extends Error {
-}
-exports.NotFoundError = NotFoundError;

package/lib/backends/Query.d.ts

@@ -1,56 +0,0 @@
-import { Filter } from './Filter';
-import { Limits } from './Limits';
-import { Sorting } from './Sorting';
-import { SortAndLimit } from './SortAndLimit';
-import { BackendInterface } from './types/BackendInterface';
-import { DataObjectClass, ObjectUri } from '../components';
-import { BaseObjectCore } from '../components/BaseObjectCore';
-export declare const AS_OBJECTURIS = "objectUris";
-export declare const AS_DATAOBJECTS = "dataObjects";
-export declare const AS_INSTANCES = "classInstances";
-export type OperatorKeys = 'equals' | 'notEquals' | 'greater' | 'greaterOrEquals' | 'lower' | 'lowerOrEquals' | 'contains' | 'notContains' | 'containsAll' | 'containsAny';
-export type QueryMetaType = {
-    count: number;
-    offset: number;
-    batch: number;
-    executionTime: string | number;
-    sortField?: string;
-    sortOrder?: 'asc' | 'desc';
-    debug?: any;
-};
-export type QueryResultType<T> = {
-    items: Array<T>;
-    meta: QueryMetaType;
-};
-export declare enum returnAs {
-    AS_OBJECTURIS = "objectUris",
-    AS_DATAOBJECTS = "dataObjects",
-    AS_INSTANCES = "classInstances",
-    AS_IS = "asIs"
-}
-export declare class Query<T extends typeof BaseObjectCore> {
-    protected _obj: T;
-    protected _parent: T | undefined;
-    filters: Filter[];
-    sortings: Sorting[];
-    limits: Limits;
-    meta: any;
-    constructor(obj: T, parent?: T);
-    get obj(): T;
-    get parent(): T | undefined;
-    /**
-     * Declare query parent record
-     * This may be need in some NoSQL backend to query subcollections
-     */
-    set parent(parent: T | undefined);
-    where(param: Filter | string | any, value?: any, operator?: OperatorKeys): this;
-    sortBy(param: Sorting | string, order?: any): this;
-    setLimits(limits: Limits): this;
-    offset(offset?: number): this;
-    batch(batch?: number): this;
-    get sortAndLimit(): SortAndLimit;
-    fetch(backend?: BackendInterface): Promise<QueryResultType<DataObjectClass<any>>>;
-    fetchAsUri(backend?: BackendInterface): Promise<QueryResultType<ObjectUri>>;
-    fetchAsInstances(backend?: BackendInterface): Promise<QueryResultType<T>>;
-    execute(as?: returnAs, backend?: BackendInterface): Promise<QueryResultType<any>>;
-}

package/lib/backends/Query.js

@@ -1,129 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    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) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Query = exports.returnAs = exports.AS_INSTANCES = exports.AS_DATAOBJECTS = exports.AS_OBJECTURIS = void 0;
-const Filter_1 = require("./Filter");
-const Limits_1 = require("./Limits");
-const Sorting_1 = require("./Sorting");
-const SortAndLimit_1 = require("./SortAndLimit");
-const Core_1 = require("../Core");
-exports.AS_OBJECTURIS = 'objectUris';
-exports.AS_DATAOBJECTS = 'dataObjects';
-exports.AS_INSTANCES = 'classInstances';
-var returnAs;
-(function (returnAs) {
-    returnAs["AS_OBJECTURIS"] = "objectUris";
-    returnAs["AS_DATAOBJECTS"] = "dataObjects";
-    returnAs["AS_INSTANCES"] = "classInstances";
-    returnAs["AS_IS"] = "asIs";
-})(returnAs || (exports.returnAs = returnAs = {}));
-class Query {
-    constructor(obj, parent) {
-        this._obj = obj;
-        this._parent = parent;
-        this.filters = [];
-        this.sortings = [];
-        this.limits = new Limits_1.Limits();
-        this.meta = {};
-    }
-    get obj() {
-        return this._obj;
-    }
-    get parent() {
-        return this._parent;
-    }
-    /**
-     * Declare query parent record
-     * This may be need in some NoSQL backend to query subcollections
-     */
-    set parent(parent) {
-        this._parent = parent;
-    }
-    where(param, value = null, operator = 'equals') {
-        if (typeof param == 'object') {
-            this.filters.push(param);
-        }
-        else {
-            if (operator === 'equals' && Array.isArray(value)) {
-                // auto-convert operator if value is an array
-                operator = 'contains';
-            }
-            this.filters.push(new Filter_1.Filter(param, value, operator));
-        }
-        return this;
-    }
-    sortBy(param, order = 'asc') {
-        if (typeof param == 'object') {
-            this.sortings.push(param);
-        }
-        else {
-            this.sortings.push(new Sorting_1.Sorting(param, order));
-        }
-        return this;
-    }
-    setLimits(limits) {
-        this.limits = limits;
-        return this;
-    }
-    offset(offset = 0) {
-        this.limits.offset = offset;
-        return this;
-    }
-    batch(batch = 10) {
-        this.limits.batch = batch;
-        return this;
-    }
-    get sortAndLimit() {
-        return new SortAndLimit_1.SortAndLimit(this.sortings, this.limits);
-    }
-    fetch(backend = Core_1.Core.getBackend()) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return backend.query(this);
-        });
-    }
-    fetchAsUri(backend = Core_1.Core.getBackend()) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { items, meta } = yield this.fetch(backend);
-            return { items: yield Promise.all(items.map((dao) => dao.uri)), meta };
-        });
-    }
-    fetchAsInstances(backend = Core_1.Core.getBackend()) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { items, meta } = yield this.fetch(backend);
-            const instances = [];
-            for (const item of items) {
-                instances.push(this._obj.fromDataObject(item));
-            }
-            return { items: instances, meta };
-        });
-    }
-    execute(as = returnAs.AS_DATAOBJECTS, backend = Core_1.Core.getBackend(this._obj.DEFAULT_BACKEND)) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                switch (as) {
-                    case exports.AS_DATAOBJECTS:
-                        return yield this.fetch(backend);
-                    case exports.AS_OBJECTURIS:
-                        return yield this.fetchAsUri(backend);
-                    case exports.AS_INSTANCES:
-                        return yield this.fetchAsInstances(backend);
-                    default:
-                        throw new Error(`Unknown output mode`);
-                }
-            }
-            catch (err) {
-                console.log(err);
-                throw err;
-            }
-        });
-    }
-}
-exports.Query = Query;

package/lib/backends/SortAndLimit.d.ts

@@ -1,11 +0,0 @@
-import { Limits } from './Limits';
-import { Sorting } from './Sorting';
-export interface SortAndLimitType {
-    sortings: Sorting[];
-    limits: Limits;
-}
-export declare class SortAndLimit implements SortAndLimitType {
-    sortings: Sorting[];
-    limits: Limits;
-    constructor(sortings?: Sorting[], limits?: Limits | undefined);
-}

package/lib/backends/SortAndLimit.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SortAndLimit = void 0;
-const Limits_1 = require("./Limits");
-class SortAndLimit {
-    constructor(sortings = [], limits = undefined) {
-        this.sortings = sortings;
-        this.limits = limits || new Limits_1.Limits();
-    }
-}
-exports.SortAndLimit = SortAndLimit;

package/lib/backends/Sorting.d.ts

@@ -1,9 +0,0 @@
-export interface SortingType {
-    prop: string;
-    order: 'asc' | 'desc';
-}
-export declare class Sorting implements SortingType {
-    prop: string;
-    order: 'asc' | 'desc';
-    constructor(prop: string, order?: 'asc' | 'desc');
-}

package/lib/backends/Sorting.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Sorting = void 0;
-class Sorting {
-    constructor(prop, order = 'asc') {
-        this.prop = prop;
-        this.order = order;
-    }
-}
-exports.Sorting = Sorting;

package/lib/backends/index.d.ts

@@ -1,12 +0,0 @@
-import { AbstractAdapter } from './AbstractAdapter';
-import { MockAdapter } from './MockAdapter';
-import { BackendError } from './BackendError';
-import { BackendInterface } from './types/BackendInterface';
-import * as CollectionHierarchy from './types/CollectionHierarchy';
-import { Query, QueryResultType, QueryMetaType } from './Query';
-import { Filter } from './Filter';
-import { Filters } from './Filters';
-import { Sorting } from './Sorting';
-import { Limits } from './Limits';
-import { SortAndLimit } from './SortAndLimit';
-export { BackendInterface, AbstractAdapter, BackendError, MockAdapter, Query, QueryResultType, QueryMetaType, Filter, Filters, Sorting, Limits, SortAndLimit, CollectionHierarchy, };

package/lib/backends/index.js

@@ -1,46 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CollectionHierarchy = exports.SortAndLimit = exports.Limits = exports.Sorting = exports.Filters = exports.Filter = exports.Query = exports.MockAdapter = exports.BackendError = exports.AbstractAdapter = void 0;
-const AbstractAdapter_1 = require("./AbstractAdapter");
-Object.defineProperty(exports, "AbstractAdapter", { enumerable: true, get: function () { return AbstractAdapter_1.AbstractAdapter; } });
-const MockAdapter_1 = require("./MockAdapter");
-Object.defineProperty(exports, "MockAdapter", { enumerable: true, get: function () { return MockAdapter_1.MockAdapter; } });
-const BackendError_1 = require("./BackendError");
-Object.defineProperty(exports, "BackendError", { enumerable: true, get: function () { return BackendError_1.BackendError; } });
-const CollectionHierarchy = __importStar(require("./types/CollectionHierarchy"));
-exports.CollectionHierarchy = CollectionHierarchy;
-const Query_1 = require("./Query");
-Object.defineProperty(exports, "Query", { enumerable: true, get: function () { return Query_1.Query; } });
-const Filter_1 = require("./Filter");
-Object.defineProperty(exports, "Filter", { enumerable: true, get: function () { return Filter_1.Filter; } });
-const Filters_1 = require("./Filters");
-Object.defineProperty(exports, "Filters", { enumerable: true, get: function () { return Filters_1.Filters; } });
-const Sorting_1 = require("./Sorting");
-Object.defineProperty(exports, "Sorting", { enumerable: true, get: function () { return Sorting_1.Sorting; } });
-const Limits_1 = require("./Limits");
-Object.defineProperty(exports, "Limits", { enumerable: true, get: function () { return Limits_1.Limits; } });
-const SortAndLimit_1 = require("./SortAndLimit");
-Object.defineProperty(exports, "SortAndLimit", { enumerable: true, get: function () { return SortAndLimit_1.SortAndLimit; } });

package/lib/backends/middlewares/AbstractMiddleware.js

@@ -1 +0,0 @@
-"use strict";

package/lib/backends/middlewares/InjectKeywordsMiddleware.d.ts

@@ -1,9 +0,0 @@
-import { DataObjectClass } from '../../components';
-import { BackendAction } from '../../Backend';
-import BackendMiddleware from './Middleware';
-export interface InjectKeywordsMiddlewareParams {
-}
-export declare class InjectKeywordsMiddleware implements BackendMiddleware {
-    execute(dataObject: DataObjectClass<any>, action: BackendAction): void;
-    protected _createKeywords(dataObject: DataObjectClass<any>): string[];
-}