@quatrain/core 1.0.0-beta9 → 1.0.1

package/lib/Core.d.ts

@@ -1,28 +1,22 @@
-import { AbstractAuthAdapter } from './authentication';
-import { AbstractAdapter } from './backends/AbstractAdapter';
 import { User } from './components/User';
 import { DataObjectClass } from './components/types/DataObjectClass';
-export type BackendRegistry<T extends AbstractAdapter> = {
-    [x: string]: T;
-};
 export declare class Core {
-    static defaultBackend: string;
+    static storage: any;
+    static storagePrefix: string;
     static userClass: typeof User;
     static classRegistry: {
         [key: string]: any;
     };
     static logger: Console;
-    static auth: AbstractAuthAdapter;
     static timestamp: () => string;
-    protected static _backends: BackendRegistry<any>;
     static definition(key: string): {
         manifest: {
             type: StringConstructor;
             mandatory: boolean;
         };
     };
-    static addBackend(backend: AbstractAdapter, alias: string, setDefault?: boolean): void;
-    static getBackend<T extends AbstractAdapter>(alias?: string): T;
+    static addConfig(key: string, value: any): Promise<void>;
+    static getConfig(key: string): Promise<any>;
     static addClass(name: string, obj: any): void;
     static getClass(name: string): any;
     /**

package/lib/Core.js

@@ -1,4 +1,13 @@
 "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.Core = void 0;
 const DataObject_1 = require("./components/DataObject");
@@ -12,19 +21,21 @@ class Core {
             },
         };
     }
-    static addBackend(backend, alias, setDefault = false) {
-        Core._backends[alias] = backend;
-        if (setDefault) {
-            Core.defaultBackend = alias;
-        }
+    static addConfig(key, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.storage.set) {
+                yield this.storage.init();
+            }
+            yield this.storage.set(`${this.storagePrefix}_${key}`, value);
+        });
     }
-    static getBackend(alias = this.defaultBackend) {
-        if (this._backends[alias]) {
-            return this._backends[alias];
-        }
-        else {
-            throw new Error(`Unknown backend alias: '${alias}'`);
-        }
+    static getConfig(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.storage.get) {
+                yield this.storage.init();
+            }
+            return yield this.storage.get(`${this.storagePrefix}_${key}`);
+        });
     }
     static addClass(name, obj) {
         Core.classRegistry[name] = obj;
@@ -51,10 +62,10 @@ class Core {
     }
 }
 exports.Core = Core;
-Core.defaultBackend = '@default';
+Core.storage = require('node-persist');
+Core.storagePrefix = 'core';
 Core.userClass = User_1.User;
 Core.classRegistry = {};
 Core.logger = console;
 // How timestamp are formatted
 Core.timestamp = () => new Date().toISOString();
-Core._backends = {};

package/lib/components/AbstractObject.d.ts

@@ -23,7 +23,7 @@ export declare abstract class AbstractObject {
     get _(): any;
     get uri(): import("./ObjectUri").ObjectUri;
     toJSON(): {
-        backend: string;
+        backend: string | undefined;
         ref: string;
         label: string;
     };

package/lib/components/BaseObjectCore.d.ts

@@ -1,36 +1,8 @@
-import { ObjectUri } from './ObjectUri';
-import { DataObjectClass } from './types/DataObjectClass';
-import { BaseObjectClass } from './types/BaseObjectClass';
+import { ObjectUri, DataObjectClass, DataObject, BaseObject } from '../';
 import { AbstractObject } from './AbstractObject';
-import { BaseObject } from './BaseObject';
-import { Query } from '../backends/Query';
-import { DataObject } from './DataObject';
-import { Persisted } from './types/Persisted';
-import { Proxy } from './types/ProxyConstructor';
-import { DataObjectProperties } from '../properties';
-export declare class BaseObjectCore extends AbstractObject implements BaseObjectClass {
-    static PROPS_DEFINITION: DataObjectProperties;
-    static getProperty(key: string): (import("../properties").NumberPropertyType & {
-        type: string;
-    }) | (import("../properties").BooleanPropertyType & {
-        type: string;
-    }) | (import("../properties").EnumPropertyType & {
-        type: string;
-    }) | (import("../properties").ObjectPropertyType & {
-        type: string;
-    }) | (import("../properties").StringPropertyType & {
-        type: string;
-    }) | (import("../properties").HashPropertyType & {
-        type: string;
-    }) | (import("../properties").DateTimeProperty & {
-        type: string;
-    }) | (import("../properties").ArrayPropertyType & {
-        type: string;
-    }) | (import("../properties").MapPropertyType & {
-        type: string;
-    }) | (import("../properties").CollectionPropertyType & {
-        type: string;
-    }) | undefined;
+export declare class BaseObjectCore extends AbstractObject {
+    static PROPS_DEFINITION: any;
+    static getProperty(key: string): any;
     static fillProperties(child?: any): DataObject;
     static daoFactory(src?: string | ObjectUri | DataObjectClass<any> | undefined, child?: any): Promise<DataObjectClass<any>>;
     /**
@@ -46,7 +18,7 @@ export declare class BaseObjectCore extends AbstractObject implements BaseObject
      * @param path
      * @returns
      */
-    static fromBackend<T>(path: string): Promise<Persisted<T>>;
+    static fromBackend<T>(path: string): Promise<T>;
     /**
      * Instantiates from a DataObject
      * @param dao
@@ -57,17 +29,5 @@ export declare class BaseObjectCore extends AbstractObject implements BaseObject
      * Wrap instance into proxy to get access to properties
      * @returns Proxy
      */
-    protected toProxy<T extends BaseObject>(): Proxy<Proxy<T>>;
     asReference(): any;
-    /**
-     * Create a query based on given class where parent is current instance
-     * @param obj
-     * @returns Query
-     */
-    query(obj: any): Query<any>;
-    /**
-     * Create a query based on current class
-     * @returns Query
-     */
-    static query(): Query<typeof BaseObjectCore>;
 }

package/lib/components/BaseObjectCore.js

@@ -10,12 +10,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseObjectCore = void 0;
-const ObjectUri_1 = require("./ObjectUri");
+const __1 = require("../");
 const AbstractObject_1 = require("./AbstractObject");
-const BaseObject_1 = require("./BaseObject");
-const Query_1 = require("../backends/Query");
-const DataObject_1 = require("./DataObject");
-const ProxyConstructor_1 = require("./types/ProxyConstructor");
 class BaseObjectCore extends AbstractObject_1.AbstractObject {
     static getProperty(key) {
         return BaseObjectCore.PROPS_DEFINITION.find((prop) => prop.name === key);
@@ -33,7 +29,7 @@ class BaseObjectCore extends AbstractObject_1.AbstractObject {
                 base.push(property);
             }
         });
-        const dao = DataObject_1.DataObject.factory({
+        const dao = __1.DataObject.factory({
             properties: base,
             parentProp: this.PARENT_PROP,
         });
@@ -43,7 +39,7 @@ class BaseObjectCore extends AbstractObject_1.AbstractObject {
     static daoFactory(src = undefined, child = this) {
         return __awaiter(this, void 0, void 0, function* () {
             const dao = this.fillProperties(child);
-            if (src instanceof ObjectUri_1.ObjectUri) {
+            if (src instanceof __1.ObjectUri) {
                 dao.uri = src;
                 yield dao.read();
             }
@@ -62,7 +58,7 @@ class BaseObjectCore extends AbstractObject_1.AbstractObject {
      */
     static fromObject(src, child = this) {
         const dao = this.fillProperties(child);
-        dao.uri = new ObjectUri_1.ObjectUri(`${this.COLLECTION}${ObjectUri_1.ObjectUri.DEFAULT}`, Reflect.get(src, 'name'));
+        dao.uri = new __1.ObjectUri(`${this.COLLECTION}${__1.ObjectUri.DEFAULT}`, Reflect.get(src, 'name'));
         dao.uri.class = child;
         dao.populateFromData(src);
         const obj = new this(dao);
@@ -71,12 +67,12 @@ class BaseObjectCore extends AbstractObject_1.AbstractObject {
     static factory(src = undefined, child = this) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                if (typeof src == 'object' && !(src instanceof ObjectUri_1.ObjectUri)) {
+                if (typeof src == 'object' && !(src instanceof __1.ObjectUri)) {
                     return this.fromObject(src);
                 }
                 const dao = yield this.daoFactory(src, child);
                 const constructedObject = Reflect.construct(this, [dao]);
-                return constructedObject.toProxy();
+                return constructedObject;
             }
             catch (err) {
                 throw new Error(`Unable to build instance for '${this.name}': ${err.message}`);
@@ -109,61 +105,47 @@ class BaseObjectCore extends AbstractObject_1.AbstractObject {
      * Wrap instance into proxy to get access to properties
      * @returns Proxy
      */
-    toProxy() {
-        return new ProxyConstructor_1.ProxyConstructor(this, {
-            get: (target, prop) => {
-                if (prop === 'uid') {
-                    return target.uid;
-                }
-                if (prop === 'uri') {
-                    return target.uri;
-                }
-                if (prop == 'toJSON') {
-                    return target.toJSON;
-                }
-                if (prop == 'save') {
-                    return target.save;
-                }
-                if (prop == 'constructor') {
-                    return target.constructor;
-                }
-                if (prop === 'core') {
-                    return target;
-                }
-                // i don't know why and i shouldn't have to wonder why
-                // but everything crashes unless we do this terribleness
-                if (prop == 'then') {
-                    return;
-                }
-                return target.val(prop);
-            },
-            set(target, prop, newValue) {
-                if (prop === 'uid' || prop === 'core') {
-                    throw new Error(`Property '${prop}' is readonly`);
-                }
-                target.set(prop, newValue);
-                return true;
-            },
-        });
-    }
+    // protected toProxy<T extends BaseObject>() {
+    //    return new ProxyConstructor<this, Proxy<T>>(this, {
+    //       get: (target, prop) => {
+    //          if (prop === 'uid') {
+    //             return target.uid
+    //          }
+    //          if (prop === 'uri') {
+    //             return target.uri
+    //          }
+    //          if (prop == 'toJSON') {
+    //             return target.toJSON
+    //          }
+    //          if (prop == 'save') {
+    //             return target.save
+    //          }
+    //          if (prop == 'constructor') {
+    //             return target.constructor
+    //          }
+    //          if (prop === 'core') {
+    //             return target
+    //          }
+    //          // i don't know why and i shouldn't have to wonder why
+    //          // but everything crashes unless we do this terribleness
+    //          if (prop == 'then') {
+    //             return
+    //          }
+    //          return target.val(prop as string)
+    //       },
+    //       set(target, prop, newValue) {
+    //          if (prop === 'uid' || prop === 'core') {
+    //             throw new Error(`Property '${prop}' is readonly`)
+    //          }
+    //          target.set(prop as string, newValue)
+    //          return true
+    //       },
+    //    })
+    // }
     asReference() {
         return this._dataObject.toReference();
     }
-    /**
-     * Create a query based on given class where parent is current instance
-     * @param obj
-     * @returns Query
-     */
-    query(obj) {
-        return new Query_1.Query(obj, this);
-    }
-    /**
-     * Create a query based on current class
-     * @returns Query
-     */
-    static query() {
-        return new Query_1.Query(this);
-    }
 }
 exports.BaseObjectCore = BaseObjectCore;
-BaseObjectCore.PROPS_DEFINITION = BaseObject_1.BaseObjectProperties;
+// implements BaseObjectClass {
+BaseObjectCore.PROPS_DEFINITION = __1.BaseObjectProperties;

package/lib/components/DataObject.d.ts

@@ -26,8 +26,8 @@ export declare class DataObject implements DataObjectClass<any> {
     protected _objectUri: ObjectUri;
     protected _uid: string | undefined;
     protected _properties: Properties;
-    protected _persisted: boolean;
     protected _populated: boolean;
+    protected _persisted: boolean;
     protected _parentProp: string | undefined;
     protected _proxied: any;
     /**
@@ -40,6 +40,7 @@ export declare class DataObject implements DataObjectClass<any> {
      */
     protected constructor(params: DataObjectParams | undefined);
     protected _init(properties: any[]): void;
+    isPersisted(): boolean;
     /**
      * Wrap instance into proxy to get access to properties
      * @returns Proxy
@@ -68,13 +69,7 @@ export declare class DataObject implements DataObjectClass<any> {
     populateFromData(data: {
         [x: string]: unknown;
     }): this;
-    /**
-     * Populate data object from backend query
-     * @param data
-     */
-    populateFromBackend(): Promise<DataObject>;
     isPopulated(): boolean;
-    isPersisted(): boolean;
     get properties(): Properties;
     get backend(): string | undefined;
     get path(): string;
@@ -85,6 +80,7 @@ export declare class DataObject implements DataObjectClass<any> {
     get uri(): ObjectUri;
     get class(): any;
     get parentProp(): string | undefined;
+    set parentProp(str: string | undefined);
     has(key: string): boolean;
     /**
      * Returns property matching key or throw

package/lib/components/DataObject.js

@@ -10,7 +10,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 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");
 const ResourcesErrors_1 = require("../common/ResourcesErrors");
@@ -27,8 +26,8 @@ class DataObject {
     constructor(params) {
         this._uid = undefined;
         this._properties = {};
-        this._persisted = false;
         this._populated = false;
+        this._persisted = false;
         /**
          * Has data been modified since last backend operation?
          */
@@ -54,6 +53,9 @@ class DataObject {
             this._properties[prop.name] = Property_1.Property.factory(prop, this);
         });
     }
+    isPersisted() {
+        return this._persisted;
+    }
     /**
      * Wrap instance into proxy to get access to properties
      * @returns Proxy
@@ -108,9 +110,8 @@ class DataObject {
             if (this._populated === false) {
                 if (data) {
                     this.populateFromData(data);
-                }
-                else if (this.path !== '/' && this.path !== '') {
-                    yield this.populateFromBackend();
+                    // } else if (this.path !== '/' && this.path !== '') {
+                    //    await this.populateFromBackend()
                 }
                 this._populated = true;
                 if (Reflect.get(this._properties, 'name')) {
@@ -131,6 +132,7 @@ class DataObject {
                     const val = data[key];
                     if (val &&
                         typeof val === 'object' &&
+                        !val.hasOwnProperty('bucket') &&
                         'ref' in val &&
                         typeof val.ref == 'string' &&
                         'label' in val &&
@@ -150,30 +152,9 @@ class DataObject {
         }
         return this;
     }
-    /**
-     * Populate data object from backend query
-     * @param data
-     */
-    populateFromBackend() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this._populated === false) {
-                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;
     }
@@ -198,7 +179,7 @@ class DataObject {
     set uri(uri) {
         this._objectUri = uri;
         if (this._objectUri.collection !== ObjectUri_1.ObjectUri.MISSING_COLLECTION) {
-            this._persisted = true;
+            //  this._persisted = true
         }
     }
     get uri() {
@@ -211,6 +192,9 @@ class DataObject {
     get parentProp() {
         return this._parentProp;
     }
+    set parentProp(str) {
+        this._parentProp = str;
+    }
     has(key) {
         return Reflect.has(this._properties, key);
     }
@@ -268,7 +252,7 @@ class DataObject {
             const prop = Reflect.get(this._properties, key);
             if (ignoreUnchanged && prop.hasChanged === false)
                 return;
-            console.log(prop.constructor.name);
+            //   console.log(prop.constructor.name);
             switch (prop.constructor.name) {
                 case 'CollectionProperty':
                     // ignore
@@ -301,27 +285,15 @@ class DataObject {
     }
     read() {
         return __awaiter(this, void 0, void 0, function* () {
-            try {
-                return yield Core_1.Core.getBackend().read(this); //this.populate()
-            }
-            catch (err) {
-                console.log(err.message);
-                throw new Error(err.message);
-            }
+            throw new Error(`This is just a stub, please use DataObject from @quatrain/backend to persist`);
         });
     }
     save() {
-        const backend = Core_1.Core.getBackend(this.backend || Core_1.Core.defaultBackend);
-        this._persisted = true;
-        this._modified = false;
-        return this.uid ? backend.update(this) : backend.create(this);
+        throw new Error(`This is just a stub, please use DataObject from @quatrain/backend to persist`);
     }
     delete() {
         return __awaiter(this, void 0, void 0, function* () {
-            const backend = Core_1.Core.getBackend(this.backend || Core_1.Core.defaultBackend);
-            this._persisted = false;
-            this._modified = false;
-            return yield backend.delete(this);
+            throw new Error(`This is just a stub, please use DataObject from @quatrain/backend to persist`);
         });
     }
     /**

package/lib/components/ObjectUri.d.ts

@@ -4,25 +4,44 @@ export declare class ObjectUri {
     protected _str: string;
     protected _pairs: Array<string>;
     protected _literal: string;
-    protected _backend: string;
+    protected _backend: string | undefined;
     protected _path: string;
     protected _uid: string | undefined;
     protected _collection: string | undefined;
     protected _label: string | undefined;
     protected _objClass: any;
+    protected _parent: ObjectUri | 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
+     * @param str partial or full resource path
+     * @param label optional label to describe path
      */
     constructor(str?: string, label?: string | undefined);
     set class(objClass: any);
     get class(): any;
-    get backend(): string;
+    get backend(): string | undefined;
+    /**
+     * Returns the full path of the resource
+     * including optional parents' path
+     * @returns string
+     */
     get path(): string;
+    /**
+     * Returns the own path of the resource
+     * without the optional parents' paths
+     * @returns string
+     */
+    get ownPath(): string;
+    get parent(): ObjectUri | undefined;
     set label(label: string | undefined);
     get label(): string | undefined;
+    /**
+     * Return the full path litteral
+     * including the backend alias
+     * @returns string
+     */
     get literal(): string;
     set path(path: string);
     get uid(): string | undefined;
@@ -38,7 +57,7 @@ export declare class ObjectUri {
         label: string | undefined;
     };
     toJSON(): {
-        backend: string;
+        backend: string | undefined;
         ref: string;
         label: string;
     };