@quatrain/core 1.0.0-beta9 → 1.0.0

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,54 +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 QueryMetaType = {
-    count: number;
-    offset: number;
-    batch: number;
-    executionTime: string | number;
-    sortField?: string;
-    sortOrder?: 'asc' | 'desc';
-};
-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, value?: any, operator?: any): 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,131 +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'; // Any'
-            }
-            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* () {
-            //<DataObjectClass<any>[] | ObjectUri[] | Persisted<BaseObject>[]> {
-            //</any><Array<T2> | Array<DataObject> | Array<ObjectUri>> {
-            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 Middleware from './Middleware';
-export interface InjectKeywordsMiddlewareParams {
-}
-export declare class InjectKeywordsMiddleware implements Middleware {
-    execute(dataObject: DataObjectClass<any>, action: BackendAction): void;
-    protected _createKeywords(dataObject: DataObjectClass<any>): string[];
-}

package/lib/backends/middlewares/InjectKeywordsMiddleware.js

@@ -1,47 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InjectKeywordsMiddleware = void 0;
-const Backend_1 = require("../../Backend");
-const properties_1 = require("../../properties");
-class InjectKeywordsMiddleware {
-    execute(dataObject, action) {
-        if (!dataObject.has('keywords')) {
-            dataObject.addProperty(new properties_1.ArrayProperty({ name: 'keywords' }));
-        }
-        switch (action) {
-            case Backend_1.BackendAction.CREATE:
-            case Backend_1.BackendAction.UPDATE:
-                dataObject.set('keywords', this._createKeywords(dataObject));
-                break;
-            default:
-                break;
-        }
-        return;
-    }
-    _createKeywords(dataObject) {
-        const keywords = [];
-        Object.keys(dataObject.properties)
-            .filter((key) => dataObject.get(key).fullSearch === true)
-            .forEach((key) => {
-            const val = dataObject.val(key);
-            if (val) {
-                val.toLowerCase()
-                    .split(' ')
-                    .forEach((word) => {
-                    let seq = '';
-                    word
-                        .split('')
-                        .splice(0, 15)
-                        .forEach((letter) => {
-                        seq += letter;
-                        if (seq.length > 1) {
-                            keywords.push(seq);
-                        }
-                    });
-                });
-            }
-        });
-        return [...new Set(keywords)];
-    }
-}
-exports.InjectKeywordsMiddleware = InjectKeywordsMiddleware;

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

@@ -1,13 +0,0 @@
-import { DataObjectClass } from '../../components';
-import { BackendAction } from '../../Backend';
-import { User } from '../../components/User';
-import Middleware from './Middleware';
-import { MiddlewareParams } from './types/MiddlewareParams';
-export interface InjectMetaMiddlewareParams {
-    user: User;
-}
-export declare class InjectMetaMiddleware implements Middleware {
-    protected _user: User;
-    constructor(params: InjectMetaMiddlewareParams);
-    execute(dataObject: DataObjectClass<any>, action: BackendAction, params?: MiddlewareParams): void;
-}

package/lib/backends/middlewares/InjectMetaMiddleware.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InjectMetaMiddleware = void 0;
-const Backend_1 = require("../../Backend");
-const Core_1 = require("../../Core");
-class InjectMetaMiddleware {
-    constructor(params) {
-        this._user = params.user;
-    }
-    execute(dataObject, action, params) {
-        Core_1.Core.log(`[MDW] Executing Middleware ${this.constructor.name}`);
-        const date = params && params.useDateFormat ? (new Date()).toISOString() : Date.now();
-        switch (action) {
-            // add properties existence validation
-            case Backend_1.BackendAction.CREATE:
-                dataObject.set('createdBy', this._user);
-                dataObject.set('createdAt', date);
-                break;
-            case Backend_1.BackendAction.UPDATE:
-                dataObject.set('updatedBy', this._user);
-                dataObject.set('updatedAt', date);
-                break;
-            case Backend_1.BackendAction.DELETE:
-                dataObject.set('deletedBy', this._user);
-                dataObject.set('deletedAt', date);
-                break;
-            default:
-                break;
-        }
-        return;
-    }
-}
-exports.InjectMetaMiddleware = InjectMetaMiddleware;

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

@@ -1,5 +0,0 @@
-import { BackendAction } from '../../Backend';
-import { DataObjectClass } from '../../components';
-export default interface Middleware {
-    execute: (dataObject: DataObjectClass<any>, action: BackendAction, params?: any) => void;
-}

package/lib/backends/middlewares/Middleware.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/lib/backends/middlewares/types/MiddlewareParams.d.ts

@@ -1,3 +0,0 @@
-export type MiddlewareParams = {
-    useDateFormat?: boolean;
-};

package/lib/backends/middlewares/types/MiddlewareParams.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/lib/backends/types/BackendInterface.d.ts

@@ -1,13 +0,0 @@
-import { DataObjectClass } from '../../components';
-import { Filter } from '../Filter';
-import { Filters } from '../Filters';
-import { Query, QueryResultType } from '../Query';
-import { SortAndLimit } from '../SortAndLimit';
-export interface BackendInterface {
-    create(dataObject: DataObjectClass<any>, desiredUid: string | undefined): Promise<DataObjectClass<any>>;
-    read(param: string | DataObjectClass<any>): Promise<DataObjectClass<any>>;
-    update(dataObject: DataObjectClass<any>): Promise<DataObjectClass<any>>;
-    delete(dataObject: DataObjectClass<any>): Promise<DataObjectClass<any>>;
-    query(query: Query<any>): Promise<QueryResultType<DataObjectClass<any>>>;
-    find(dataObject: DataObjectClass<any>, filters: Filters | Filter[] | undefined, pagination: SortAndLimit | undefined, parent: any): Promise<QueryResultType<DataObjectClass<any>>>;
-}

package/lib/backends/types/BackendInterface.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/lib/backends/types/CollectionHierarchy.d.ts

@@ -1,3 +0,0 @@
-export declare const STANDARD = 1;
-export declare const SUBCOLLECTION = 2;
-export declare const SUBCOLLECTION_GROUP = 3;

package/lib/backends/types/CollectionHierarchy.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SUBCOLLECTION_GROUP = exports.SUBCOLLECTION = exports.STANDARD = void 0;
-exports.STANDARD = 1;
-exports.SUBCOLLECTION = 2;
-exports.SUBCOLLECTION_GROUP = 3;