@quatrain/core 0.1.6

package/lib/components/BaseObject.d.ts

@@ -0,0 +1,16 @@
+import { ObjectUri } from './ObjectUri';
+import { AbstractObject } from './AbstractObject';
+import { DataObjectProperties } from '../properties';
+import { Query } from '../backends';
+export declare class BaseObject extends AbstractObject {
+    static PROPS_DEFINITION: DataObjectProperties;
+    get status(): string;
+    set status(status: string);
+    static factory<T extends BaseObject>(src?: string | ObjectUri | object | undefined): Promise<T | BaseObject>;
+    asReference(): {
+        label: any;
+        ref: string;
+        uri: string;
+    };
+    query(): Query<this>;
+}

package/lib/components/BaseObject.js

@@ -0,0 +1,73 @@
+"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.BaseObject = void 0;
+const DataObject_1 = require("./DataObject");
+const ObjectUri_1 = require("./ObjectUri");
+const AbstractObject_1 = require("./AbstractObject");
+const BaseObjectProperties_1 = require("./BaseObjectProperties");
+const backends_1 = require("../backends");
+class BaseObject extends AbstractObject_1.AbstractObject {
+    get status() {
+        return this._dataObject.val('status');
+    }
+    set status(status) {
+        this._dataObject.set('status', status);
+    }
+    static factory(src = undefined) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // merge base properties with additional or redefined ones
+                const base = BaseObjectProperties_1.BaseObjectProperties;
+                // this.PROPS_DEFINITION &&
+                this.PROPS_DEFINITION.forEach((property) => {
+                    // manage parent properties potential redeclaration
+                    const found = base.findIndex((el) => el.name === property.name);
+                    if (found !== -1) {
+                        base[found] = Object.assign(base[found], property);
+                    }
+                    else {
+                        base.push(property);
+                    }
+                });
+                //console.log('props to add', JSON.stringify(base))
+                // create data object
+                const dao = yield DataObject_1.DataObject.factory(this.prototype, base);
+                if (src instanceof ObjectUri_1.ObjectUri) {
+                    dao.uri = src;
+                    yield dao.populate();
+                }
+                else if (typeof src === 'string') {
+                    dao.uri.path = src;
+                    yield dao.populate();
+                }
+                else if (src instanceof Object) {
+                    dao.uri = new ObjectUri_1.ObjectUri(`${this.COLLECTION}${ObjectUri_1.ObjectUri.DEFAULT}`, Reflect.get(src, 'name'));
+                    dao.uri.collection = this.COLLECTION;
+                    yield dao.populate(src);
+                }
+                return new this(dao);
+            }
+            catch (err) {
+                console.log(err.message);
+                throw new Error(`Unable to build instance for '${this.constructor.name}': ${err.message}`);
+            }
+        });
+    }
+    asReference() {
+        return this._dataObject.toReference();
+    }
+    query() {
+        return new backends_1.Query(this);
+    }
+}
+exports.BaseObject = BaseObject;
+BaseObject.PROPS_DEFINITION = BaseObjectProperties_1.BaseObjectProperties;

package/lib/components/BaseObjectProperties.d.ts

@@ -0,0 +1,15 @@
+import { DataObjectProperties } from '../properties';
+import * as statuses from '../statuses';
+import { User } from './User';
+import { ObjectUri } from './ObjectUri';
+export interface BaseObjectType {
+    name: string;
+    status: typeof statuses.CREATED | typeof statuses.PENDING | typeof statuses.ACTIVE | typeof statuses.DELETED;
+    createdBy?: User | ObjectUri;
+    createdAt?: number;
+    updatedBy?: User | ObjectUri;
+    updatedAt?: number;
+    deletedBy?: User | ObjectUri;
+    deletedAt?: number;
+}
+export declare const BaseObjectProperties: DataObjectProperties;

package/lib/components/BaseObjectProperties.js

@@ -0,0 +1,82 @@
+"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.BaseObjectProperties = void 0;
+const Property_1 = require("../properties/Property");
+const statuses = __importStar(require("../statuses"));
+exports.BaseObjectProperties = [
+    {
+        name: 'name',
+        mandatory: true,
+        type: Property_1.Property.TYPE_STRING,
+        minLength: 1,
+        maxLength: 100,
+    },
+    {
+        name: 'status',
+        mandatory: true,
+        type: Property_1.Property.TYPE_ENUM,
+        values: [
+            statuses.CREATED,
+            statuses.PENDING,
+            statuses.ACTIVE,
+            statuses.DELETED,
+        ],
+        defaultValue: statuses.CREATED,
+    },
+    {
+        name: 'createdBy',
+        type: Property_1.Property.TYPE_OBJECT,
+        instanceOf: 'User',
+        mandatory: true,
+        protected: true,
+    },
+    {
+        name: 'createdAt',
+        type: Property_1.Property.TYPE_DATETIME,
+        mandatory: true,
+        protected: true,
+    },
+    {
+        name: 'updatedBy',
+        type: Property_1.Property.TYPE_OBJECT,
+        instanceOf: 'User',
+    },
+    {
+        name: 'updatedAt',
+        type: Property_1.Property.TYPE_DATETIME,
+    },
+    {
+        name: 'deletedBy',
+        type: Property_1.Property.TYPE_OBJECT,
+        instanceOf: 'User',
+        protected: true,
+    },
+    {
+        name: 'deletedAt',
+        type: Property_1.Property.TYPE_DATETIME,
+        protected: true,
+    },
+];

package/lib/components/DataObject.d.ts

@@ -0,0 +1,83 @@
+import { AbstractObject } from './AbstractObject';
+import { ObjectUri } from './ObjectUri';
+export interface DataObjectFactoryType {
+    path: string;
+    [x: string]: any;
+}
+export declare type CoreObject<T extends AbstractObject> = T;
+/**
+ * Data objects constitute the agnostic glue between objects and backends.
+ * They handle data and identifiers in a protected registry
+ * This is what backends and objects manipulate, oblivious of the other.
+ */
+export declare class DataObject {
+    protected _class: CoreObject<any>;
+    protected _objectUri: ObjectUri;
+    protected _obj: any;
+    protected _uid: string | undefined;
+    protected _properties: {
+        [x: string]: any;
+    };
+    protected _persisted: boolean;
+    protected _populated: boolean;
+    /**
+     * Has data been modified since last backend operation?
+     */
+    protected _modified: boolean;
+    /**
+     * Constructor is protected, use factory() instead
+     * @param objClass AbstractObject
+     * @param properties array of properties instances
+     */
+    protected constructor(objClass: AbstractObject, properties: any[] | undefined);
+    protected _init(properties: any[]): void;
+    /**
+     * Populate data object from instant data or backend query
+     * @param data
+     */
+    populate(data?: any): Promise<DataObject>;
+    isPopulated(): boolean;
+    isPersisted(): boolean;
+    get properties(): {
+        [x: string]: any;
+    };
+    get backend(): string | undefined;
+    get class(): any;
+    get path(): string;
+    set uid(uid: string | undefined);
+    get uid(): string | undefined;
+    get data(): any;
+    set uri(uri: string | ObjectUri | undefined);
+    get uri(): ObjectUri;
+    /**
+     * Returns property matching key or throw
+     * @param key string
+     * @returns BaseProperty
+     */
+    get(key: string): any;
+    set(key: string, val: any): this;
+    /**
+     * Get value of given property
+     * @param key string
+     * @returns any
+     */
+    val(key: string): any;
+    toJSON(): {
+        [x: string]: any;
+    };
+    toReference(): {
+        label: any;
+        ref: string;
+        uri: string;
+    };
+    protected _dataToJSON(): {};
+    read(): Promise<DataObject>;
+    save(desiredUid?: string | undefined): Promise<DataObject>;
+    /**
+     * Data object must be created from factory in order for async-loaded data to be available
+     * @param className
+     * @param param
+     * @returns DataObject
+     */
+    static factory(className: any, param?: any[] | undefined): Promise<DataObject>;
+}

package/lib/components/DataObject.js

@@ -0,0 +1,209 @@
+"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.DataObject = void 0;
+const Core_1 = require("../Core");
+const Property_1 = require("../properties/Property");
+const ObjectUri_1 = require("./ObjectUri");
+/**
+ * Data objects constitute the agnostic glue between objects and backends.
+ * They handle data and identifiers in a protected registry
+ * This is what backends and objects manipulate, oblivious of the other.
+ */
+class DataObject {
+    /**
+     * Constructor is protected, use factory() instead
+     * @param objClass AbstractObject
+     * @param properties array of properties instances
+     */
+    constructor(objClass, properties) {
+        this._uid = undefined;
+        this._properties = {};
+        this._persisted = false;
+        this._populated = false;
+        /**
+         * Has data been modified since last backend operation?
+         */
+        this._modified = false;
+        this._class = objClass;
+        this._objectUri = new ObjectUri_1.ObjectUri();
+        if (Array.isArray(properties)) {
+            this._init(properties);
+        }
+    }
+    _init(properties) {
+        // console.log(
+        //    `Preparing properties for instance of ${this._class.constructor.name}`
+        // )
+        properties.forEach((prop) => {
+            this._properties[prop.name] = Property_1.Property.factory(prop, this);
+        });
+    }
+    /**
+     * Populate data object from instant data or backend query
+     * @param data
+     */
+    populate(data = undefined) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._populated === false) {
+                if (data) {
+                    for (const key in data) {
+                        if (Reflect.get(this._properties, key)) {
+                            Reflect.get(this._properties, key).set(data[key]);
+                        }
+                    }
+                }
+                else if (this.path !== '/' && this.path !== '') {
+                    yield Core_1.Core.getBackend(this._objectUri.backend).read(this);
+                }
+                this._populated = true;
+                if (Reflect.get(this._properties, 'name')) {
+                    this.uri.label = this.val('name');
+                }
+            }
+            return this;
+        });
+    }
+    isPopulated() {
+        return this._populated;
+    }
+    isPersisted() {
+        return this._persisted;
+    }
+    get properties() {
+        return this._properties;
+    }
+    get backend() {
+        return this._objectUri ? this._objectUri.backend : undefined;
+    }
+    get class() {
+        return this._class;
+    }
+    get path() {
+        return this._objectUri ? this._objectUri.path : '';
+    }
+    set uid(uid) {
+        if (this._uid !== undefined) {
+            throw new Error(`DataObject already has an uid`);
+        }
+        this._uid = uid;
+    }
+    get uid() {
+        return this._objectUri ? this._objectUri.uid : undefined;
+    }
+    get data() {
+        return this._properties;
+    }
+    set uri(uri) {
+        this._objectUri = uri instanceof ObjectUri_1.ObjectUri ? uri : new ObjectUri_1.ObjectUri(uri);
+    }
+    get uri() {
+        return this._objectUri;
+    }
+    /**
+     * Returns property matching key or throw
+     * @param key string
+     * @returns BaseProperty
+     */
+    get(key) {
+        try {
+            return this._properties[key];
+        }
+        catch (err) {
+            throw new Error(err.message);
+        }
+    }
+    set(key, val) {
+        if (!Reflect.has(this._properties, key)) {
+            throw new Error(`Unknown property in data object: ${key}`);
+        }
+        this._properties[key].set(val);
+        this._populated = true;
+        this._modified = true;
+        return this;
+    }
+    /**
+     * Get value of given property
+     * @param key string
+     * @returns any
+     */
+    val(key) {
+        if (Reflect.get(this._properties, key)) {
+            return Reflect.get(this._properties, key).val();
+        }
+        else {
+            throw new Error(`Unknown property '${key}'`);
+        }
+    }
+    toJSON() {
+        return Object.assign(Object.assign({}, (this._uid && { uid: this._uid })), this._dataToJSON());
+    }
+    toReference() {
+        var _a;
+        return Object.assign(Object.assign({}, (_a = this._objectUri) === null || _a === void 0 ? void 0 : _a.toReference()), { label: this.val('name') });
+    }
+    _dataToJSON() {
+        const data = {};
+        Object.keys(this._properties).forEach((key) => {
+            const prop = Reflect.get(this._properties, key);
+            if (typeof prop.val() === 'object' &&
+                Reflect.has(prop.val(), 'toJSON')) {
+                Reflect.set(data, key, prop.val().toJSON());
+            }
+            else if (prop !== undefined) {
+                Reflect.set(data, key, prop.val());
+            }
+        });
+        return data;
+    }
+    read() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return this.populate(Core_1.Core.getBackend().read(this));
+            }
+            catch (err) {
+                console.log(err.message);
+                throw new Error(err.message);
+            }
+        });
+    }
+    save(desiredUid = undefined) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const backend = Core_1.Core.getBackend(this.backend || Core_1.Core.defaultBackend);
+            this._persisted = true;
+            this._modified = false;
+            return this._uid
+                ? yield backend.update(this)
+                : yield backend.create(this, desiredUid);
+        });
+    }
+    /**
+     * Data object must be created from factory in order for async-loaded data to be available
+     * @param className
+     * @param param
+     * @returns DataObject
+     */
+    static factory(className, param = undefined) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (className === undefined) {
+                throw new Error(`className is a require value`);
+            }
+            try {
+                return new this(className, param);
+            }
+            catch (err) {
+                console.log(err);
+                throw new Error(`Unable to build data object: ${err.message}`);
+            }
+        });
+    }
+}
+exports.DataObject = DataObject;

package/lib/components/ObjectUri.d.ts

@@ -0,0 +1,42 @@
+export declare class ObjectUri {
+    static DEFAULT: string;
+    static MISSING_COLLECTION: string;
+    protected _str: string;
+    protected _pairs: Array<string>;
+    protected _literal: string;
+    protected _backend: string;
+    protected _path: string;
+    protected _uid: string | undefined;
+    protected _collection: string | undefined;
+    protected _label: string | undefined;
+    /**
+     * create object uri from string:
+     * ex: 'xyz', '@backend:xyz', 'collection/xyz', '@backend:collection/xyz'
+     * some backends will need a collection or table name, some may deduct it from object
+     * @param str
+     */
+    constructor(str?: string, label?: string | undefined);
+    get backend(): string;
+    get path(): string;
+    set label(label: string | undefined);
+    get label(): string | undefined;
+    get literal(): string;
+    set path(path: string);
+    get uid(): string | undefined;
+    get collection(): string | undefined;
+    set collection(collection: string | undefined);
+    /**
+     * Return references to find object locally and remotely
+     * @returns object
+     */
+    toReference(): {
+        ref: string;
+        uri: string;
+        label: string | undefined;
+    };
+    toJSON(): {
+        literal: string;
+        ref: string;
+        label: string | undefined;
+    };
+}

package/lib/components/ObjectUri.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectUri = void 0;
+const Core_1 = require("../Core");
+class ObjectUri {
+    /**
+     * create object uri from string:
+     * ex: 'xyz', '@backend:xyz', 'collection/xyz', '@backend:collection/xyz'
+     * some backends will need a collection or table name, some may deduct it from object
+     * @param str
+     */
+    constructor(str = '', label = undefined) {
+        this._pairs = [];
+        this._literal = '';
+        this._backend = Core_1.Core.defaultBackend;
+        this._path = ObjectUri.DEFAULT;
+        this._uid = undefined;
+        this._collection = undefined;
+        this._str = str;
+        this._label = label || this._uid;
+        if (str.indexOf(':') !== -1) {
+            const [backend, path] = str.split(':');
+            this._backend = backend || Core_1.Core.defaultBackend;
+            this._path = path;
+        }
+        else {
+            this._path = str;
+        }
+        const parts = this._path.split(ObjectUri.DEFAULT);
+        if (parts.length === 1) {
+            // It is allowed to only give the uid part of the uri
+            // provided that collection will be injected by another mean
+            this._uid = parts[0].length > 0 ? parts[0] : undefined;
+            this._collection = ObjectUri.MISSING_COLLECTION;
+            this._pairs.push(`${ObjectUri.MISSING_COLLECTION}${ObjectUri.DEFAULT}${this._uid}`);
+        }
+        else if (parts.length % 2 === 0) {
+            // General case is a path containing pairs of collection/uid
+            let i = 0;
+            while (i < parts.length) {
+                this._collection = parts[i];
+                this._uid = parts[i + 1];
+                this._pairs.push(`${parts[i]}${ObjectUri.DEFAULT}${parts[i + 1]}`);
+                i += 2;
+            }
+        }
+        else {
+            throw new Error('Path parts number must be 1 or even');
+        }
+    }
+    get backend() {
+        return this._backend;
+    }
+    get path() {
+        return this._path;
+    }
+    set label(label) {
+        this._label = label;
+    }
+    get label() {
+        return this._label;
+    }
+    get literal() {
+        // return `${this._backend}:${
+        //    this._collection || ObjectUri.MISSING_COLLECTION
+        // }${ObjectUri.DEFAULT}${this._uid}`
+        return `${this._backend}:${this._pairs.join(ObjectUri.DEFAULT)}`;
+    }
+    set path(path) {
+        if (this._path && this._path !== ObjectUri.DEFAULT) {
+            throw new Error(`Path value already set with '${this._path}'`);
+        }
+        this._path = path;
+        this._collection = path.split('/').pop();
+        this._literal = `${this._backend}:${this._path}`;
+    }
+    get uid() {
+        return this._uid;
+    }
+    get collection() {
+        return this._collection === ObjectUri.MISSING_COLLECTION
+            ? undefined
+            : this._collection;
+    }
+    set collection(collection) {
+        if (this.collection !== undefined) {
+            throw new Error('Collection value already set');
+        }
+        this._collection = collection;
+    }
+    /**
+     * Return references to find object locally and remotely
+     * @returns object
+     */
+    toReference() {
+        return {
+            ref: this._path,
+            uri: this._literal,
+            label: this._label,
+        };
+    }
+    toJSON() {
+        return {
+            literal: this._literal,
+            ref: this._path,
+            label: this._label,
+        };
+    }
+}
+exports.ObjectUri = ObjectUri;
+ObjectUri.DEFAULT = '/';
+ObjectUri.MISSING_COLLECTION = '_?_';

package/lib/components/User.d.ts

@@ -0,0 +1,6 @@
+import { DataObjectProperties } from '../properties';
+import { BaseObject } from './BaseObject';
+export declare const UserProperties: DataObjectProperties;
+export declare class User extends BaseObject {
+    static PROPS_DEFINITION: DataObjectProperties;
+}