@quatrain/core 0.4.4 → 0.5.0

package/lib/components/BaseObject.js

@@ -1,81 +1,87 @@
 "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 __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.BaseObject = void 0;
-const ObjectUri_1 = require("./ObjectUri");
-const AbstractObject_1 = require("./AbstractObject");
-const BaseObjectProperties_1 = require("./BaseObjectProperties");
-const Query_1 = require("../backends/Query");
-const DataObject_1 = require("./DataObject");
-class BaseObject extends AbstractObject_1.AbstractObject {
-    static getProperty(key) {
-        return BaseObject.PROPS_DEFINITION.find((prop) => prop.name === key);
-    }
-    get status() {
-        return this._dataObject.val('status');
-    }
-    set status(status) {
-        this._dataObject.set('status', status);
-    }
-    static daoFactory(src = undefined, child = this) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // merge base properties with additional or redefined ones
-            const base = [...BaseObject.PROPS_DEFINITION];
-            // this.PROPS_DEFINITION &&
-            child.PROPS_DEFINITION.forEach((property) => {
-                // manage parent properties potential redeclaration
-                const found = base.findIndex((el) => el.name === property.name);
-                if (found !== -1) {
-                    base[found] = property;
-                }
-                else {
-                    base.push(property);
-                }
-            });
-            // create data object
-            const dao = yield DataObject_1.DataObject.factory({ properties: base });
-            dao.uri.class = child;
-            if (src instanceof ObjectUri_1.ObjectUri) {
-                dao.uri = src;
-                yield dao.read();
-            }
-            else if (typeof src === 'string') {
-                dao.uri.path = src;
-                yield dao.read();
-            }
-            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 dao;
-        });
-    }
-    static factory(src = undefined, child = this) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const dao = yield this.daoFactory(src, child);
-                return Reflect.construct(this, [dao]);
-            }
-            catch (err) {
-                throw new Error(`Unable to build instance for '${this.name}': ${err.message}`);
-            }
-        });
-    }
-    asReference() {
-        return this._dataObject.toReference();
-    }
-    query() {
-        return new Query_1.Query(this.constructor.prototype);
-    }
-}
-exports.BaseObject = BaseObject;
-BaseObject.PROPS_DEFINITION = BaseObjectProperties_1.BaseObjectProperties;
+exports.BaseObjectProperties = void 0;
+const statuses = __importStar(require("../statuses"));
+const StringProperty_1 = require("../properties/StringProperty");
+const ObjectProperty_1 = require("../properties/ObjectProperty");
+const EnumProperty_1 = require("../properties/EnumProperty");
+const DateTimeProperty_1 = require("../properties/DateTimeProperty");
+const htmlType = __importStar(require("../properties/types/PropertyHTMLType"));
+exports.BaseObjectProperties = [
+    {
+        name: 'name',
+        mandatory: true,
+        type: StringProperty_1.StringProperty.TYPE,
+        minLength: 1,
+        maxLength: 100,
+        htmlType: htmlType.NAME,
+    },
+    {
+        name: 'status',
+        mandatory: true,
+        type: EnumProperty_1.EnumProperty.TYPE,
+        values: [
+            statuses.CREATED,
+            statuses.PENDING,
+            statuses.ACTIVE,
+            statuses.DELETED,
+        ],
+        defaultValue: statuses.CREATED,
+    },
+    {
+        name: 'createdBy',
+        type: ObjectProperty_1.ObjectProperty.TYPE,
+        instanceOf: 'User',
+        mandatory: true,
+        protected: true,
+    },
+    {
+        name: 'createdAt',
+        type: DateTimeProperty_1.DateTimeProperty.TYPE,
+        mandatory: true,
+        protected: true,
+    },
+    {
+        name: 'updatedBy',
+        type: ObjectProperty_1.ObjectProperty.TYPE,
+        instanceOf: 'User',
+    },
+    {
+        name: 'updatedAt',
+        type: DateTimeProperty_1.DateTimeProperty.TYPE,
+    },
+    {
+        name: 'deletedBy',
+        type: ObjectProperty_1.ObjectProperty.TYPE,
+        instanceOf: 'User',
+        protected: true,
+    },
+    {
+        name: 'deletedAt',
+        type: DateTimeProperty_1.DateTimeProperty.TYPE,
+        protected: true,
+    },
+];

package/lib/components/BaseObjectCore.d.ts

@@ -0,0 +1,60 @@
+import { ObjectUri } from './ObjectUri';
+import { DataObjectClass } from './types/DataObjectClass';
+import { BaseObjectClass } from './types/BaseObjectClass';
+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;
+    static fillProperties(child?: any): DataObject;
+    static daoFactory(src?: string | ObjectUri | DataObjectClass<any> | undefined, child?: any): Promise<DataObjectClass<any>>;
+    /**
+     * Instantiates from an object
+     * @param src
+     * @param child
+     * @returns
+     */
+    static fromObject<T extends BaseObject>(src: T, child?: any): Proxy<T>;
+    static factory(src?: string | ObjectUri | BaseObject | undefined, child?: any): Promise<any>;
+    /**
+     * Fetches an object from its backend path
+     * @param path
+     * @returns
+     */
+    static fromBackend<T>(path: string): Promise<Persisted<T>>;
+    /**
+     * Instantiates from a DataObject
+     * @param dao
+     * @returns
+     */
+    static fromDataObject<T extends BaseObject>(dao: DataObjectClass<any>): T;
+    protected toProxy<T extends BaseObject>(): Proxy<Proxy<T>>;
+    asReference(): any;
+    query(): Query<any>;
+    static query(): Query<typeof BaseObjectCore>;
+}

package/lib/components/BaseObjectCore.js

@@ -0,0 +1,153 @@
+"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.BaseObjectCore = void 0;
+const ObjectUri_1 = require("./ObjectUri");
+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);
+    }
+    static fillProperties(child = this) {
+        // merge base properties with additional or redefined ones
+        const base = [...BaseObjectCore.PROPS_DEFINITION];
+        child.PROPS_DEFINITION.forEach((property) => {
+            // manage parent properties potential redeclaration
+            const found = base.findIndex((el) => el.name === property.name);
+            if (found !== -1) {
+                base[found] = property;
+            }
+            else {
+                base.push(property);
+            }
+        });
+        const dao = DataObject_1.DataObject.factory({ properties: base });
+        dao.uri.class = child;
+        return dao;
+    }
+    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) {
+                dao.uri = src;
+                yield dao.read();
+            }
+            else if (typeof src == 'string') {
+                dao.uri.path = src;
+                yield dao.read();
+            }
+            return dao;
+        });
+    }
+    /**
+     * Instantiates from an object
+     * @param src
+     * @param child
+     * @returns
+     */
+    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.class = child;
+        dao.populateFromData(src);
+        const obj = new this(dao);
+        return obj.toProxy();
+    }
+    static factory(src = undefined, child = this) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (typeof src == 'object' && !(src instanceof ObjectUri_1.ObjectUri)) {
+                    return this.fromObject(src);
+                }
+                const dao = yield this.daoFactory(src, child);
+                const constructedObject = Reflect.construct(this, [dao]);
+                return constructedObject.toProxy();
+            }
+            catch (err) {
+                throw new Error(`Unable to build instance for '${this.name}': ${err.message}`);
+            }
+        });
+    }
+    /**
+     * Fetches an object from its backend path
+     * @param path
+     * @returns
+     */
+    static fromBackend(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!path.includes('/')) {
+                return this.factory(`${this.COLLECTION}/${path}`);
+            }
+            return this.factory(path);
+        });
+    }
+    /**
+     * Instantiates from a DataObject
+     * @param dao
+     * @returns
+     */
+    static fromDataObject(dao) {
+        const obj = new this(dao);
+        return obj.toProxy();
+    }
+    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;
+            },
+        });
+    }
+    asReference() {
+        return this._dataObject.toReference();
+    }
+    query() {
+        return new Query_1.Query(this.constructor.prototype);
+    }
+    static query() {
+        return new Query_1.Query(this);
+    }
+}
+exports.BaseObjectCore = BaseObjectCore;
+BaseObjectCore.PROPS_DEFINITION = BaseObject_1.BaseObjectProperties;

package/lib/components/BaseRepository.d.ts

@@ -0,0 +1,24 @@
+import { BackendInterface } from '../backends/AbstractAdapter';
+import { Query } from '../backends/Query';
+import { BaseObjectCore } from './BaseObjectCore';
+import { DataObjectClass } from './types/DataObjectClass';
+import Payload from './types/Payload';
+import RepositoryClass from './types/RepositoryClass';
+import { BaseObject } from './BaseObject';
+import { Persisted } from './types/Persisted';
+import { Proxy } from './types/ProxyConstructor';
+/**
+ * CRUD methods for models/entities inheriting from BaseObject
+ * Extend this by passing the typeof of the desired class to the constructor
+ */
+export default class BaseRepository<T extends BaseObject> implements RepositoryClass<T> {
+    protected model: typeof BaseObjectCore;
+    backendAdapter: BackendInterface;
+    constructor(model: typeof BaseObjectCore, backendAdapter?: BackendInterface);
+    protected getDataObjectFromUid(uid: string): Promise<DataObjectClass<any>>;
+    create(obj: Proxy<T>, uid?: string): Promise<Persisted<T>>;
+    read(uid: string): Promise<Persisted<T>>;
+    update(obj: Proxy<T>): Promise<Persisted<T>>;
+    delete(uid: string): Promise<void>;
+    query(query: Query<typeof BaseObjectCore>): Promise<Payload<Persisted<T>>>;
+}

package/lib/components/BaseRepository.js

@@ -0,0 +1,116 @@
+"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;
+};
+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 });
+const Core_1 = require("../Core");
+const statuses = __importStar(require("../statuses"));
+const ResourcesErrors_1 = require("../common/ResourcesErrors");
+const DataObject_1 = require("./DataObject");
+const RESOURCE_GONE_ERROR = `The resource you are trying to access has been deleted.`;
+/**
+ * CRUD methods for models/entities inheriting from BaseObject
+ * Extend this by passing the typeof of the desired class to the constructor
+ */
+class BaseRepository {
+    constructor(model, backendAdapter = Core_1.Core.getBackend()) {
+        this.model = model;
+        this.backendAdapter = backendAdapter;
+    }
+    getDataObjectFromUid(uid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const collection = this.model.COLLECTION || this.model.name.toLowerCase();
+            const path = `${collection}/${uid}`;
+            const dataObject = yield DataObject_1.DataObject.factory({
+                properties: this.model.PROPS_DEFINITION,
+                uri: path,
+            });
+            dataObject.uid = uid;
+            return dataObject;
+        });
+    }
+    create(obj, uid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dataObject = obj.core.dataObject;
+            const savedObj = yield this.backendAdapter.create(dataObject, uid);
+            return this.model.fromDataObject(savedObj);
+        });
+    }
+    read(uid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const dataObject = yield this.getDataObjectFromUid(uid);
+                const response = yield this.backendAdapter.read(dataObject);
+                const obj = this.model.fromDataObject(response);
+                if (obj.status === statuses.DELETED) {
+                    throw new ResourcesErrors_1.GoneError(RESOURCE_GONE_ERROR);
+                }
+                return obj;
+            }
+            catch (e) {
+                if (e instanceof ResourcesErrors_1.GoneError) {
+                    throw e;
+                }
+                if (e instanceof ResourcesErrors_1.NotFoundError) {
+                    throw new ResourcesErrors_1.NotFoundError('[Repository] ' + e.message);
+                }
+                throw e;
+            }
+        });
+    }
+    update(obj) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dataObject = obj.core.dataObject;
+            const savedObj = yield this.backendAdapter.update(dataObject);
+            return this.model.fromDataObject(savedObj);
+        });
+    }
+    delete(uid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dataObject = yield this.getDataObjectFromUid(uid);
+            yield this.backendAdapter.delete(dataObject);
+        });
+    }
+    query(query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const items = (yield query.fetchAsInstances(this.backendAdapter));
+            const count = yield this.backendAdapter.count(query);
+            const meta = {
+                count,
+                updatedAt: new Date().getTime(),
+            };
+            const payload = { items, meta };
+            return payload;
+        });
+    }
+}
+exports.default = BaseRepository;

package/lib/components/DataObject.d.ts

@@ -3,8 +3,8 @@ import { PropertyClassType } from '../properties/types/PropertyClassType';
 import { AbstractObject } from './AbstractObject';
 import { ObjectUri } from './ObjectUri';
 import { DataObjectClass } from './types/DataObjectClass';
-export declare type CoreObject<T extends AbstractObject> = T;
-export declare type Properties = {
+export type CoreObject<T extends AbstractObject> = T;
+export type Properties = {
     [x: string]: PropertyClassType;
 };
 export interface DataObjectFactoryType {
@@ -41,7 +41,22 @@ export declare class DataObject implements DataObjectClass<any> {
      * Populate data object from instant data or backend query
      * @param data
      */
-    populate(data?: any): Promise<DataObject>;
+    populate(data?: {
+        name: string;
+        [x: string]: unknown;
+    } | undefined): Promise<DataObject>;
+    /**
+     * Populate data object from instant data or backend query
+     * @param data
+     */
+    populateFromData(data: {
+        [x: string]: unknown;
+    }): this;
+    /**
+     * Populate data object from backend query
+     * @param data
+     */
+    populateFromBackend(): Promise<DataObject>;
     isPopulated(): boolean;
     isPersisted(): boolean;
     get properties(): Properties;
@@ -85,6 +100,6 @@ export declare class DataObject implements DataObjectClass<any> {
      * @param param
      * @returns DataObject
      */
-    static factory(param?: DataObjectParams | undefined): Promise<DataObject>;
+    static factory(param?: DataObjectParams | undefined): DataObject;
     clone(data?: any): Promise<DataObject>;
 }

package/lib/components/DataObject.js

@@ -64,13 +64,45 @@ class DataObject {
         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]);
-                        }
-                    }
+                    this.populateFromData(data);
                 }
                 else if (this.path !== '/' && this.path !== '') {
+                    yield this.populateFromBackend();
+                }
+                this._populated = true;
+                if (Reflect.get(this._properties, 'name')) {
+                    this.uri.label = this.val('name');
+                }
+            }
+            return this;
+        });
+    }
+    /**
+     * Populate data object from instant data or backend query
+     * @param data
+     */
+    populateFromData(data) {
+        if (this._populated === false) {
+            for (const key in data) {
+                if (Reflect.get(this._properties, key)) {
+                    Reflect.get(this._properties, key).set(data[key]);
+                }
+            }
+            this._populated = true;
+            if (Reflect.get(this._properties, 'name')) {
+                this.uri.label = this.val('name');
+            }
+        }
+        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;
@@ -176,8 +208,8 @@ class DataObject {
                 case 'ObjectProperty':
                     const value = prop.val();
                     Reflect.set(data, key, value
-                        ? objectsAsReferences
-                            ? value.toReference()
+                        ? objectsAsReferences && !(value instanceof ObjectUri_1.ObjectUri)
+                            ? value.core.asReference() //toReference()
                             : value.toJSON()
                         : null);
                     break;
@@ -190,7 +222,7 @@ class DataObject {
     read() {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                return this.populate(yield Core_1.Core.getBackend().read(this));
+                return yield Core_1.Core.getBackend().read(this); //this.populate()
             }
             catch (err) {
                 console.log(err.message);
@@ -219,21 +251,22 @@ class DataObject {
      * @returns DataObject
      */
     static factory(param = undefined) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                return new this(param);
-            }
-            catch (err) {
-                console.log(err);
-                throw new Error(`Unable to build data object: ${err.message}`);
-            }
-        });
+        try {
+            return new this(param);
+        }
+        catch (err) {
+            console.log(err);
+            throw new Error(`Unable to build data object: ${err.message}`);
+        }
     }
     clone(data = {}) {
         return __awaiter(this, void 0, void 0, function* () {
             const cloned = yield DataObject.factory();
             cloned.uri.class = this.uri.class;
-            cloned.setProperties(this._properties);
+            cloned._populated = false;
+            for (let property of Object.keys(this._properties)) {
+                cloned._properties[property] = this._properties[property].clone();
+            }
             if (data) {
                 yield cloned.populate(data);
             }