@quatrain/core 0.1.6

package/lib/Core.d.ts

@@ -0,0 +1,16 @@
+import { AbstractAdapter } from './backends';
+export declare type BackendRegistry<T extends AbstractAdapter> = {
+    [x: string]: T;
+};
+export declare class Core {
+    static defaultBackend: string;
+    protected static _backends: BackendRegistry<any>;
+    static definition(key: string): {
+        manifest: {
+            type: StringConstructor;
+            mandatory: boolean;
+        };
+    };
+    static addBackend(backend: AbstractAdapter, alias: string): void;
+    static getBackend(alias?: string): any;
+}

package/lib/Core.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Core = void 0;
+const backends_1 = require("./backends");
+class Core {
+    static definition(key) {
+        return {
+            manifest: {
+                type: String,
+                mandatory: true,
+            },
+        };
+    }
+    static addBackend(backend, alias) {
+        Core._backends[alias] = backend;
+    }
+    static getBackend(alias = this.defaultBackend) {
+        if (this._backends[alias]) {
+            return this._backends[alias];
+        }
+        else {
+            throw new Error(`Unknown backend alias: '${alias}'`);
+        }
+    }
+}
+exports.Core = Core;
+Core.defaultBackend = '@default';
+Core._backends = {
+    '@mock': new backends_1.MockAdapter({ alias: '@mock' }),
+};

package/lib/backends/AbstractAdapter.d.ts

@@ -0,0 +1,49 @@
+import { BaseObject, DataObject } from '../components';
+import { Filter } from './Filter';
+import { Filters } from './Filters';
+import { Query } from './Query';
+import { SortAndLimit } from './SortAndLimit';
+/**
+ * Default interface for a backend record
+ */
+export interface BackendRecordType {
+    uid: string | undefined;
+    [key: string]: string | number | boolean | any[] | Object | undefined;
+}
+/**
+ * Backend Parameters acceptable keys
+ */
+export declare type BackendParametersKeys = 'alias' | 'mapping' | 'injectMeta' | 'config' | 'fixtures' | 'softDelete' | 'debug';
+/**
+ * Backend parameters interface
+ */
+export interface BackendParameters {
+    alias?: string;
+    mapping?: {
+        [x: string]: any;
+    };
+    injectMeta?: boolean;
+    config?: any;
+    fixtures?: any;
+    softDelete?: boolean;
+    debug?: boolean;
+}
+export interface BackendInterface<T extends BaseObject> {
+    create(dataObject: DataObject, desiredUid: string | undefined): Promise<DataObject>;
+    read(param: string | DataObject): Promise<DataObject>;
+    update(dataObject: DataObject): Promise<DataObject>;
+    delete(dataObject: DataObject): Promise<DataObject>;
+    query(query: Query<T>): Promise<DataObject[] | T[]>;
+    find(dataObject: DataObject, filters: Filters | Filter[] | undefined, pagination: SortAndLimit | undefined): Promise<DataObject[] | T[]>;
+}
+export declare abstract class AbstractAdapter {
+    protected _alias: string;
+    protected _params: BackendParameters;
+    protected _injectMeta: boolean;
+    constructor(params: BackendParameters);
+    setParam(key: BackendParametersKeys, value: any): void;
+    getParam(key: BackendParametersKeys): any;
+    set alias(alias: string);
+    get alias(): string;
+    log(message: string): void;
+}

package/lib/backends/AbstractAdapter.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractAdapter = void 0;
+class AbstractAdapter {
+    constructor(params) {
+        this._alias = '';
+        this._params = {};
+        this._injectMeta = false;
+        this._alias = params.alias || '';
+        this._injectMeta = params.injectMeta || false;
+    }
+    setParam(key, value) {
+        this._params[key] = value;
+    }
+    getParam(key) {
+        return this._params[key];
+    }
+    set alias(alias) {
+        this._alias = alias;
+    }
+    get alias() {
+        return this._alias;
+    }
+    log(message) {
+        if (this._params['debug'] === true) {
+            console.log(message);
+        }
+    }
+}
+exports.AbstractAdapter = AbstractAdapter;

package/lib/backends/BackendError.d.ts

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

package/lib/backends/BackendError.js

@@ -0,0 +1,6 @@
+"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

@@ -0,0 +1,15 @@
+import { FilterOperatorType } from './FilterOperators';
+export interface FilterType {
+    prop: string;
+    operator: FilterOperatorType | undefined;
+    value: number | string | string[] | undefined;
+}
+/**
+ * Filter object
+ */
+export declare class Filter implements FilterType {
+    prop: string;
+    operator: FilterOperatorType;
+    value: number | string | string[] | undefined;
+    constructor(prop: string, value?: number | string | string[] | undefined, operator?: FilterOperatorType);
+}

package/lib/backends/Filter.js

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

package/lib/backends/FilterOperators.d.ts

@@ -0,0 +1,13 @@
+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 declare type FilterOperatorType = 'equals' | 'notEquals' | 'greater' | 'greaterOrEquals' | 'lower' | 'lowerOrEquals' | 'contains' | 'notContains' | 'containsAll' | 'containsAny';

package/lib/backends/FilterOperators.js

@@ -0,0 +1,16 @@
+"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 || (exports.FilterOperator = {}));

package/lib/backends/Filters.d.ts

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

package/lib/backends/Filters.js

@@ -0,0 +1,14 @@
+"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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,10 @@
+"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

@@ -0,0 +1,24 @@
+import { AbstractAdapter, BackendInterface } from './';
+import { BaseObject, DataObject } from '../components';
+import { BackendRecordType } from './AbstractAdapter';
+import { Query } from './Query';
+import { Filter } from './Filter';
+import { Filters } from './Filters';
+import { SortAndLimit } from './SortAndLimit';
+export declare class MockAdapter<T extends BaseObject> extends AbstractAdapter implements BackendInterface<T> {
+    protected static _fixtures: any;
+    /**
+     * Inject fixtures data to backend adapter
+     * Force this backend to be default one
+     * @param data BackendRecordType
+     */
+    static inject(data: BackendRecordType): void;
+    static getFixtures(): any;
+    static getFixture(key: string): any;
+    create(dataObject: DataObject, desiredUid?: string | undefined): Promise<DataObject>;
+    read(dataObject: DataObject): Promise<DataObject>;
+    update(dataObject: DataObject): Promise<DataObject>;
+    delete(dataObject: DataObject): Promise<DataObject>;
+    query(query: Query<T>): Promise<DataObject[]>;
+    find(dataObject: DataObject, filters?: Filters | Filter[] | undefined, pagination?: SortAndLimit | undefined): Promise<DataObject[]>;
+}

package/lib/backends/MockAdapter.js

@@ -0,0 +1,81 @@
+"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 _1 = require("./");
+const statuses_1 = require("../statuses");
+const Core_1 = require("../Core");
+class MockAdapter extends _1.AbstractAdapter {
+    /**
+     * Inject fixtures data to backend adapter
+     * Force this backend to be default one
+     * @param data BackendRecordType
+     */
+    static inject(data) {
+        if (data.uid) {
+            MockAdapter._fixtures[data.uid] = data;
+            Core_1.Core.defaultBackend = '@mock';
+        }
+        else {
+            throw new Error(`Can't inject data without uid`);
+        }
+    }
+    static getFixtures() {
+        return MockAdapter._fixtures;
+    }
+    static getFixture(key) {
+        return MockAdapter._fixtures[key];
+    }
+    create(dataObject, desiredUid = undefined) {
+        const uri = desiredUid ||
+            `${dataObject.class.constructor.name.toLowerCase()}/${Date.now()}`;
+        MockAdapter.inject(Object.assign(Object.assign({}, dataObject.toJSON()), { uid: uri }));
+        dataObject.uri = uri;
+        return new Promise(() => dataObject);
+    }
+    read(dataObject) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const path = dataObject.path;
+            const data = MockAdapter._fixtures[path];
+            if (data === undefined) {
+                throw new Error(`[Mock] No data for ${path}`);
+            }
+            this.log(`[DAO] Populating ${dataObject.path}`);
+            return yield dataObject.populate(data);
+        });
+    }
+    update(dataObject) {
+        return new Promise(() => dataObject);
+    }
+    delete(dataObject) {
+        if (this.getParam('softDelete') === true) {
+            dataObject.set('status', statuses_1.DELETED);
+            MockAdapter.inject(Object.assign(Object.assign({}, dataObject.toJSON()), { uid: dataObject.uid }));
+        }
+        else if (dataObject.uid !== undefined) {
+            delete MockAdapter._fixtures[dataObject.uid];
+            dataObject.uri = undefined;
+        }
+        return new Promise(() => dataObject);
+    }
+    query(query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.find(query.obj.dataObject, query.filters, query.sortAndLimit);
+        });
+    }
+    find(dataObject, filters = undefined, pagination = undefined) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [dataObject, dataObject];
+        });
+    }
+}
+exports.MockAdapter = MockAdapter;
+MockAdapter._fixtures = {};

package/lib/backends/Query.d.ts

@@ -0,0 +1,24 @@
+import { Filter } from './Filter';
+import { Limits } from './Limits';
+import { Sorting } from './Sorting';
+import { SortAndLimit } from './SortAndLimit';
+import { BackendInterface } from './AbstractAdapter';
+import { BaseObject } from '../components';
+export declare class Query<T extends BaseObject> {
+    protected _obj: T;
+    protected _params: any;
+    filters: Filter[];
+    sortings: Sorting[];
+    limits: Limits;
+    constructor(obj: T, params?: {
+        [x: string]: any;
+    });
+    get obj(): T;
+    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;
+    execute(backend: BackendInterface<T>): Promise<import("../components").DataObject[] | T[]>;
+}

package/lib/backends/Query.js

@@ -0,0 +1,72 @@
+"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 = void 0;
+const Filter_1 = require("./Filter");
+const Limits_1 = require("./Limits");
+const Sorting_1 = require("./Sorting");
+const SortAndLimit_1 = require("./SortAndLimit");
+class Query {
+    constructor(obj, params = {}) {
+        this._obj = obj;
+        //Object.keys(params).forEach((key: string) => (obj[key] = params[key]))
+        this._params = params; // just in case
+        this.filters = [];
+        this.sortings = [];
+        this.limits = new Limits_1.Limits();
+    }
+    get obj() {
+        return this._obj;
+    }
+    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 = 'containsAny';
+            }
+            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);
+    }
+    execute(backend) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield backend.find(this._obj.dataObject, this.filters, this.sortAndLimit);
+        });
+    }
+}
+exports.Query = Query;

package/lib/backends/SortAndLimit.d.ts

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,11 @@
+"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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,10 @@
+"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

@@ -0,0 +1,10 @@
+import { AbstractAdapter, BackendInterface, BackendParameters } from './AbstractAdapter';
+import { MockAdapter } from './MockAdapter';
+import { BackendError } from './BackendError';
+import { Query } from './Query';
+import { Filter } from './Filter';
+import { Filters } from './Filters';
+import { Sorting } from './Sorting';
+import { Limits } from './Limits';
+import { SortAndLimit } from './SortAndLimit';
+export { AbstractAdapter, BackendInterface, BackendParameters, BackendError, MockAdapter, Query, Filter, Filters, Sorting, Limits, SortAndLimit, };

package/lib/backends/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 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/common/statuses.d.ts

@@ -0,0 +1,11 @@
+export declare const CREATED = "created";
+export declare const PENDING = "pending";
+export declare const ACTIVE = "active";
+export declare const ERROR = "error";
+export declare const TEST = "test";
+export declare const SUSPENDED = "suspended";
+export declare const DELETABLE = "deletable";
+export declare const DELETED = "deleted";
+export declare const DONE = "done";
+export declare const MAINTENANCE = "maintenance";
+export declare const UNKNOWN = "unknown";

package/lib/common/statuses.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UNKNOWN = exports.MAINTENANCE = exports.DONE = exports.DELETED = exports.DELETABLE = exports.SUSPENDED = exports.TEST = exports.ERROR = exports.ACTIVE = exports.PENDING = exports.CREATED = void 0;
+exports.CREATED = 'created';
+exports.PENDING = 'pending';
+exports.ACTIVE = 'active';
+exports.ERROR = 'error';
+exports.TEST = 'test';
+exports.SUSPENDED = 'suspended';
+exports.DELETABLE = 'deletable';
+exports.DELETED = 'deleted';
+exports.DONE = 'done';
+exports.MAINTENANCE = 'maintenance';
+exports.UNKNOWN = 'unknown';

package/lib/components/AbstractObject.d.ts

@@ -0,0 +1,23 @@
+import { DataObject } from './DataObject';
+import { DataObjectProperties } from '../properties/';
+export declare abstract class AbstractObject {
+    static PROPS_DEFINITION: DataObjectProperties;
+    static COLLECTION: string;
+    static LABEL_KEY: string;
+    protected _dataObject: DataObject;
+    constructor(dao: DataObject);
+    get(key: string): any;
+    set(key: string, val: any): DataObject;
+    val(key: string): any;
+    get backend(): string | undefined;
+    get path(): string;
+    get uid(): string | undefined;
+    get dataObject(): DataObject;
+    get uri(): import("./ObjectUri").ObjectUri;
+    toJSON(): {
+        literal: string;
+        ref: string;
+        label: string | undefined;
+    };
+    save(uid?: string | undefined): Promise<DataObject>;
+}

package/lib/components/AbstractObject.js

@@ -0,0 +1,64 @@
+"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());
+    });
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractObject = void 0;
+class AbstractObject {
+    constructor(dao) {
+        this._dataObject = dao;
+    }
+    get(key) {
+        return this._dataObject.get(key);
+    }
+    set(key, val) {
+        return this._dataObject.set(key, val);
+    }
+    val(key) {
+        const prop = this.get(key);
+        if (prop) {
+            return prop.val();
+        }
+        else {
+            throw new Error(`${key} is not a valid property`);
+        }
+    }
+    get backend() {
+        return this._dataObject.backend;
+    }
+    get path() {
+        return this._dataObject.path;
+    }
+    get uid() {
+        return this._dataObject.uid;
+    }
+    get dataObject() {
+        return this._dataObject;
+    }
+    get uri() {
+        return this._dataObject.uri;
+    }
+    toJSON() {
+        var _b;
+        return typeof this.uri === 'string' ? this.uri : (_b = this.uri) === null || _b === void 0 ? void 0 : _b.toJSON();
+    }
+    save(uid = undefined) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._dataObject.save(uid);
+        });
+    }
+}
+exports.AbstractObject = AbstractObject;
+_a = AbstractObject;
+AbstractObject.PROPS_DEFINITION = [];
+// Which name to use in backend as table/collection identifer
+AbstractObject.COLLECTION = _a.constructor.name.toLowerCase();
+// Which property's value to use in backend as label for object reference
+AbstractObject.LABEL_KEY = 'name';