@jd-data-limited/easy-fm 3.0.4 → 3.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jd-data-limited/easy-fm",
-  "version": "3.0.4",
+  "version": "3.0.6",
   "dependencies": {
     "@types/btoa": "^1.2.3",
     "@types/events": "^3.0.0",

package/src/index.js

@@ -1366,8 +1366,8 @@ class LayoutRecordManager {
     range(start = 0, limit = 100) {
         return new RecordGetRange(this.layout, start, limit);
     }
-    find() {
-        return new Find(this.layout);
+    find(start = 0, limit = 100) {
+        return new Find(this.layout, start, limit);
     }
 }
 export class RecordBase extends EventEmitter {
@@ -1384,19 +1384,6 @@ export class RecordBase extends EventEmitter {
     get edited() {
         return !!this.fields.find(i => i.edited);
     }
-    processPortalData(portalData) {
-        this.portals = [];
-        for (let item of Object.keys(portalData)) {
-            let _portal = new Portal(this, item);
-            _portal.records = portalData[item].map(item => {
-                let fieldData = item;
-                delete fieldData.recordId;
-                delete fieldData.modId;
-                return new PortalRecord(this, _portal, item.recordId, item.modId, fieldData);
-            });
-            this.portals.push(_portal);
-        }
-    }
     processFieldData(fieldData) {
         return Object.keys(fieldData).map(item => {
             let _field = new Field(this, item, fieldData[item]);
@@ -1429,36 +1416,62 @@ export class RecordBase extends EventEmitter {
             return _field;
         });
     }
-    get() {
-        let trace = new Error();
-        if (this.recordId === -1) {
-            throw "Cannot get this RecordBase until a commit() is done.";
-        }
-        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-            if (!this.layout.metadata)
-                yield this.layout.getLayoutMeta();
-            this.layout.database.apiRequest(this.endpoint, {
-                port: 443,
-                method: "GET"
-            })
-                .then(res => {
-                if (res.messages[0].code === "0") {
-                    // console.log(res, res.response.data)
-                    this.modId = res.response.data[0].modId;
-                    this.fields = this.processFieldData(res.response.data[0].fieldData);
-                    this.portalData = [];
-                    if (res.response.data[0].portalData)
-                        this.processPortalData(res.response.data[0].portalData);
-                    resolve(this);
-                }
-                else {
-                    reject(new FMError(res.messages[0].code, res.status, res, trace));
+    _onSave() {
+        this.emit("saved");
+        for (let field of this.fields)
+            field.edited = false;
+    }
+    getField(field) {
+        return this.fields.find(_field => _field.id === field);
+    }
+    toObject(filter = (a) => a.edited, portalFilter = (a) => a.records.find(record => record.edited), portalRowFilter = (a) => a.edited, portalFieldFilter = (a) => a.edited) {
+        let fields_processed = {};
+        for (let field of this.fields.filter(field => filter(field))) {
+            let value = field.value;
+            if (value instanceof Date) {
+                // @ts-ignore
+                let _value = moment.default(value)
+                    .utcOffset(this.layout.database.host.timezoneOffset);
+                // @ts-ignore
+                switch (field.metadata.result) {
+                    case "time":
+                        value = _value.format(this.layout.database.host.metadata.productInfo.timeFormat.replace("dd", "DD"));
+                        break;
+                    case "date":
+                        value = _value.format(this.layout.database.host.metadata.productInfo.dateFormat.replace("dd", "DD"));
+                        break;
+                    default:
+                        value = _value.format(this.layout.database.host.metadata.productInfo.timeStampFormat.replace("dd", "DD"));
                 }
-            })
-                .catch(e => {
-                reject(e);
-            });
-        }));
+            }
+            fields_processed[field.id] = value;
+        }
+        let obj = {
+            "recordId": this.recordId,
+            "modId": this.modId,
+            "fieldData": fields_processed
+        };
+        // Check if there's been any edited portal information
+        let portals = this.portals.filter(a => portalFilter(a));
+        if (portals) {
+            obj["portalData"] = {};
+            for (let portal of portals) {
+                obj["portalData"][portal.name] = portal.records.filter(a => portalRowFilter(a)).map(record => {
+                    return record.toObject(portalFieldFilter);
+                });
+            }
+        }
+        return obj;
+    }
+}
+export class LayoutRecord extends RecordBase {
+    constructor(layout, recordId, modId = recordId, fieldData = {}, portalData = null) {
+        super(layout, recordId, modId);
+        this.fields = this.processFieldData(fieldData);
+        this.portals = [];
+        if (portalData) {
+            this.processPortalData(portalData);
+        }
     }
     commit(extraBody = {}) {
         let trace = new Error();
@@ -1531,31 +1544,40 @@ export class RecordBase extends EventEmitter {
             });
         }));
     }
-    _onSave() {
-        this.emit("saved");
-        for (let field of this.fields)
-            field.edited = false;
-    }
-    getField(field) {
-        return this.fields.find(_field => _field.id === field);
-    }
-    getPortal(portal) {
-        return this.portals.find(p => p.name === portal);
+    processPortalData(portalData) {
+        this.portals = [];
+        for (let item of Object.keys(portalData)) {
+            let _portal = new Portal(this, item);
+            _portal.records = portalData[item].map(item => {
+                let fieldData = item;
+                delete fieldData.recordId;
+                delete fieldData.modId;
+                return new PortalRecord(this, _portal, item.recordId, item.modId, fieldData);
+            });
+            this.portals.push(_portal);
+        }
     }
-    delete() {
+    get() {
         let trace = new Error();
+        if (this.recordId === -1) {
+            throw "Cannot get this RecordBase until a commit() is done.";
+        }
         return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+            if (!this.layout.metadata)
+                yield this.layout.getLayoutMeta();
             this.layout.database.apiRequest(this.endpoint, {
                 port: 443,
-                method: "DELETE"
+                method: "GET"
             })
                 .then(res => {
-                if (typeof res.response.scriptError !== "undefined" && res.response.scriptError !== '0') {
-                    reject(new FMError(res.response.scriptError, res.status, res, trace));
-                }
-                else if (res.messages[0].code === "0") {
-                    this.emit("deleted");
-                    resolve();
+                if (res.messages[0].code === "0") {
+                    // console.log(res, res.response.data)
+                    this.modId = res.response.data[0].modId;
+                    this.fields = this.processFieldData(res.response.data[0].fieldData);
+                    this.portalData = [];
+                    if (res.response.data[0].portalData)
+                        this.processPortalData(res.response.data[0].portalData);
+                    resolve(this);
                 }
                 else {
                     reject(new FMError(res.messages[0].code, res.status, res, trace));
@@ -1566,6 +1588,9 @@ export class RecordBase extends EventEmitter {
             });
         }));
     }
+    getPortal(portal) {
+        return this.portals.find(p => p.name === portal);
+    }
     duplicate() {
         let trace = new Error();
         return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
@@ -1592,54 +1617,29 @@ export class RecordBase extends EventEmitter {
             });
         }));
     }
-    toObject(filter = (a) => a.edited, portalFilter = (a) => a.records.find(record => record.edited), portalRowFilter = (a) => a.edited, portalFieldFilter = (a) => a.edited) {
-        let fields_processed = {};
-        for (let field of this.fields.filter(field => filter(field))) {
-            let value = field.value;
-            if (value instanceof Date) {
-                // @ts-ignore
-                let _value = moment.default(value)
-                    .utcOffset(this.layout.database.host.timezoneOffset);
-                // @ts-ignore
-                switch (field.metadata.result) {
-                    case "time":
-                        value = _value.format(this.layout.database.host.metadata.productInfo.timeFormat.replace("dd", "DD"));
-                        break;
-                    case "date":
-                        value = _value.format(this.layout.database.host.metadata.productInfo.dateFormat.replace("dd", "DD"));
-                        break;
-                    default:
-                        value = _value.format(this.layout.database.host.metadata.productInfo.timeStampFormat.replace("dd", "DD"));
+    delete() {
+        let trace = new Error();
+        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+            this.layout.database.apiRequest(this.endpoint, {
+                port: 443,
+                method: "DELETE"
+            })
+                .then(res => {
+                if (typeof res.response.scriptError !== "undefined" && res.response.scriptError !== '0') {
+                    reject(new FMError(res.response.scriptError, res.status, res, trace));
                 }
-            }
-            fields_processed[field.id] = value;
-        }
-        let obj = {
-            "recordId": this.recordId,
-            "modId": this.modId,
-            "fieldData": fields_processed
-        };
-        // Check if there's been any edited portal information
-        let portals = this.portals.filter(a => portalFilter(a));
-        if (portals) {
-            obj["portalData"] = {};
-            for (let portal of portals) {
-                obj["portalData"][portal.name] = portal.records.filter(a => portalRowFilter(a)).map(record => {
-                    return record.toObject(portalFieldFilter);
-                });
-            }
-        }
-        return obj;
-    }
-}
-export class LayoutRecord extends RecordBase {
-    constructor(layout, recordId, modId = recordId, fieldData = {}, portalData = null) {
-        super(layout, recordId, modId);
-        this.fields = this.processFieldData(fieldData);
-        this.portals = [];
-        if (portalData) {
-            this.processPortalData(portalData);
-        }
+                else if (res.messages[0].code === "0") {
+                    this.emit("deleted");
+                    resolve();
+                }
+                else {
+                    reject(new FMError(res.messages[0].code, res.status, res, trace));
+                }
+            })
+                .catch(e => {
+                reject(e);
+            });
+        }));
     }
 }
 export class Field {
@@ -1722,6 +1722,24 @@ export class Field {
         // if (this.metadata.result === "container") throw "Use await field.stream() to get the contents of a container field, instead of field.value"
         return this._value;
     }
+    get string() {
+        if (typeof this._value === "string") {
+            return this._value;
+        }
+        throw "Field value is not a string";
+    }
+    get date() {
+        if (this._value instanceof Date) {
+            return this._value;
+        }
+        throw "Field value is not a date";
+    }
+    get number() {
+        if (typeof this._value === "number") {
+            return this._value;
+        }
+        throw "Field value is not a number";
+    }
     upload(buffer, filename, mime) {
         let trace = new Error();
         if (this.metadata.result !== "container")
@@ -1940,8 +1958,10 @@ export class RecordGetRange extends RecordGetOperation {
     }
 }
 export class Find extends RecordGetOperation {
-    constructor(layout) {
+    constructor(layout, start = 0, limit = 100) {
         super(layout);
+        this.setOffset(start);
+        this.setLimit(limit);
         this.queries = [];
     }
     toObject() {

package/src/index.ts

@@ -1423,14 +1423,14 @@ export class Layout {
     /**
      * @deprecated use layout.records.create() instead
      */
-    createRecord(): Promise<RecordBase | Error | void> {
+    createRecord(): Promise<LayoutRecord> {
         return this.records.create()
     }
 
     /**
      * @deprecated use layout.records.get() instead
      */
-    getRecord(recordId): Promise<RecordBase> {
+    getRecord(recordId): Promise<LayoutRecord> {
         return this.records.get(recordId)
     }
 
@@ -1441,7 +1441,7 @@ export class Layout {
         return this.records.find()
     }
 
-    runScript(script): Promise<string | FMError | Error> {
+    runScript(script): Promise<string> {
         let trace = new Error()
         return new Promise(async (resolve, reject) => {
             let url = `${this.endpoint}/script/${encodeURIComponent(script.name)}`
@@ -1488,7 +1488,7 @@ class LayoutRecordManager {
         this.layout = layout
     }
 
-    create(): Promise<RecordBase | Error | void> {
+    create(): Promise<LayoutRecord> {
         return new Promise((resolve, reject) => {
             // Get the layout's metadata
             this.layout.getLayoutMeta().then(layout => {
@@ -1505,7 +1505,7 @@ class LayoutRecordManager {
         })
     }
 
-    get(recordId): Promise<RecordBase> {
+    get(recordId): Promise<LayoutRecord> {
         return new Promise((resolve, reject) => {
             let record
             this.layout.getLayoutMeta()
@@ -1526,8 +1526,8 @@ class LayoutRecordManager {
         return new RecordGetRange(this.layout, start, limit)
     }
 
-    find(): Find {
-        return new Find(this.layout)
+    find(start = 0, limit = 100): Find {
+        return new Find(this.layout, start, limit)
     }
 }
 
@@ -1554,20 +1554,6 @@ export class RecordBase extends EventEmitter {
         return !!this.fields.find(i => i.edited)
     }
 
-    protected processPortalData(portalData): void {
-        this.portals = []
-        for (let item of Object.keys(portalData)) {
-            let _portal = new Portal(this, item)
-            _portal.records = portalData[item].map(item => {
-                let fieldData = item;
-                delete fieldData.recordId;
-                delete fieldData.modId;
-                return new PortalRecord(this, _portal, item.recordId, item.modId, fieldData);
-            })
-            this.portals.push(_portal);
-        }
-    }
-
     processFieldData(fieldData): Field[] {
         return Object.keys(fieldData).map(item => {
             let _field = new Field(this, item, fieldData[item])
@@ -1602,38 +1588,76 @@ export class RecordBase extends EventEmitter {
         })
     }
 
-    get() {
-        let trace = new Error()
-        if (this.recordId === -1) {
-            throw "Cannot get this RecordBase until a commit() is done."
+    _onSave() {
+        this.emit("saved")
+        for (let field of this.fields) field.edited = false
+    }
+
+    getField(field) {
+        return this.fields.find(_field => _field.id === field)
+    }
+
+    toObject(filter = (a) => a.edited,
+             portalFilter = (a) => a.records.find(record => record.edited),
+             portalRowFilter = (a) => a.edited,
+             portalFieldFilter = (a) => a.edited
+    ): recordObject {
+        let fields_processed = {}
+        for (let field of this.fields.filter(field => filter(field))) {
+            let value = field.value
+            if (value instanceof Date) {
+                // @ts-ignore
+                let _value = moment.default(value)
+                    .utcOffset(this.layout.database.host.timezoneOffset)
+
+                // @ts-ignore
+
+                switch (field.metadata.result) {
+                    case "time":
+                        value = _value.format(this.layout.database.host.metadata.productInfo.timeFormat.replace("dd", "DD"))
+                        break
+                    case "date":
+                        value = _value.format(this.layout.database.host.metadata.productInfo.dateFormat.replace("dd", "DD"))
+                        break
+                    default:
+                        value = _value.format(this.layout.database.host.metadata.productInfo.timeStampFormat.replace("dd", "DD"))
+                }
+            }
+            fields_processed[field.id] = value
+        }
+        let obj = {
+            "recordId": this.recordId,
+            "modId": this.modId,
+            "fieldData": fields_processed
         }
-        return new Promise(async (resolve, reject) => {
-            if (!this.layout.metadata) await this.layout.getLayoutMeta()
 
-            this.layout.database.apiRequest(this.endpoint, {
-                port: 443,
-                method: "GET"
-            })
-                .then(res => {
-                    if (res.messages[0].code === "0") {
-                        // console.log(res, res.response.data)
-                        this.modId = res.response.data[0].modId
-                        this.fields = this.processFieldData(res.response.data[0].fieldData)
-                        this.portalData = []
-                        if (res.response.data[0].portalData) this.processPortalData(res.response.data[0].portalData)
-                        resolve(this)
-                    }
-                    else {
-                        reject(new FMError(res.messages[0].code, res.status, res, trace))
-                    }
-                })
-                .catch(e => {
-                    reject(e)
+        // Check if there's been any edited portal information
+        let portals = this.portals.filter(a => portalFilter(a))
+        if (portals) {
+            obj["portalData"] = {}
+            for (let portal of portals) {
+                obj["portalData"][portal.name] = portal.records.filter(a => portalRowFilter(a)).map(record => {
+                    return record.toObject(portalFieldFilter)
                 })
-        })
+            }
+        }
+        return obj
+    }
+}
+
+export class LayoutRecord extends RecordBase {
+    portals: Portal[];
+
+    constructor(layout, recordId, modId = recordId, fieldData = {}, portalData = null) {
+        super(layout, recordId, modId);
+        this.fields = this.processFieldData(fieldData)
+        this.portals = []
+        if (portalData) {
+            this.processPortalData(portalData)
+        }
     }
 
-    commit(extraBody: extraBodyOptions = {}): Promise<RecordBase | FMError> {
+    commit(extraBody: extraBodyOptions = {}): Promise<this> {
         let trace = new Error()
         return new Promise(async (resolve, reject) => {
             let data = this.toObject()
@@ -1706,33 +1730,72 @@ export class RecordBase extends EventEmitter {
         })
     }
 
-    _onSave() {
-        this.emit("saved")
-        for (let field of this.fields) field.edited = false
+    protected processPortalData(portalData): void {
+        this.portals = []
+        for (let item of Object.keys(portalData)) {
+            let _portal = new Portal(this, item)
+            _portal.records = portalData[item].map(item => {
+                let fieldData = item;
+                delete fieldData.recordId;
+                delete fieldData.modId;
+                return new PortalRecord(this, _portal, item.recordId, item.modId, fieldData);
+            })
+            this.portals.push(_portal);
+        }
     }
 
-    getField(field) {
-        return this.fields.find(_field => _field.id === field)
+    get(): Promise<this> {
+        let trace = new Error()
+        if (this.recordId === -1) {
+            throw "Cannot get this RecordBase until a commit() is done."
+        }
+        return new Promise(async (resolve, reject) => {
+            if (!this.layout.metadata) await this.layout.getLayoutMeta()
+
+            this.layout.database.apiRequest(this.endpoint, {
+                port: 443,
+                method: "GET"
+            })
+                .then(res => {
+                    if (res.messages[0].code === "0") {
+                        // console.log(res, res.response.data)
+                        this.modId = res.response.data[0].modId
+                        this.fields = this.processFieldData(res.response.data[0].fieldData)
+                        this.portalData = []
+                        if (res.response.data[0].portalData) this.processPortalData(res.response.data[0].portalData)
+                        resolve(this)
+                    }
+                    else {
+                        reject(new FMError(res.messages[0].code, res.status, res, trace))
+                    }
+                })
+                .catch(e => {
+                    reject(e)
+                })
+        })
     }
 
     getPortal(portal) {
         return this.portals.find(p => p.name === portal)
     }
 
-    delete(): Promise<void> {
+    duplicate(): Promise<LayoutRecord> {
         let trace = new Error()
         return new Promise(async (resolve, reject) => {
             this.layout.database.apiRequest(this.endpoint, {
                 port: 443,
-                method: "DELETE"
+                method: "POST"
             })
                 .then(res => {
                     if (typeof res.response.scriptError !== "undefined" && res.response.scriptError !== '0') {
                         reject(new FMError(res.response.scriptError, res.status, res, trace))
                     }
                     else if (res.messages[0].code === "0") {
-                        this.emit("deleted")
-                        resolve()
+                        let data = this.toObject((a) => true, (a) => true, (a) => false, (a) => false)
+                        let _res = new LayoutRecord(this.layout, res.response.recordId, res.response.modId, data.fieldData, data.portalData)
+
+                        this.emit("duplicated")
+                        resolve(_res)
                     }
                     else {
                         reject(new FMError(res.messages[0].code, res.status, res, trace))
@@ -1744,23 +1807,20 @@ export class RecordBase extends EventEmitter {
         })
     }
 
-    duplicate(): Promise<RecordBase> {
+    delete(): Promise<void> {
         let trace = new Error()
         return new Promise(async (resolve, reject) => {
             this.layout.database.apiRequest(this.endpoint, {
                 port: 443,
-                method: "POST"
+                method: "DELETE"
             })
                 .then(res => {
                     if (typeof res.response.scriptError !== "undefined" && res.response.scriptError !== '0') {
                         reject(new FMError(res.response.scriptError, res.status, res, trace))
                     }
                     else if (res.messages[0].code === "0") {
-                        let data = this.toObject((a) => true, (a) => true, (a) => false, (a) => false)
-                        let _res = new LayoutRecord(this.layout, res.response.recordId, res.response.modId, data.fieldData, data.portalData)
-
-                        this.emit("duplicated")
-                        resolve(_res)
+                        this.emit("deleted")
+                        resolve()
                     }
                     else {
                         reject(new FMError(res.messages[0].code, res.status, res, trace))
@@ -1771,67 +1831,6 @@ export class RecordBase extends EventEmitter {
                 })
         })
     }
-
-
-    toObject(filter = (a) => a.edited,
-             portalFilter = (a) => a.records.find(record => record.edited),
-             portalRowFilter = (a) => a.edited,
-             portalFieldFilter = (a) => a.edited
-    ): recordObject {
-        let fields_processed = {}
-        for (let field of this.fields.filter(field => filter(field))) {
-            let value = field.value
-            if (value instanceof Date) {
-                // @ts-ignore
-                let _value = moment.default(value)
-                    .utcOffset(this.layout.database.host.timezoneOffset)
-
-                // @ts-ignore
-
-                switch (field.metadata.result) {
-                    case "time":
-                        value = _value.format(this.layout.database.host.metadata.productInfo.timeFormat.replace("dd", "DD"))
-                        break
-                    case "date":
-                        value = _value.format(this.layout.database.host.metadata.productInfo.dateFormat.replace("dd", "DD"))
-                        break
-                    default:
-                        value = _value.format(this.layout.database.host.metadata.productInfo.timeStampFormat.replace("dd", "DD"))
-                }
-            }
-            fields_processed[field.id] = value
-        }
-        let obj = {
-            "recordId": this.recordId,
-            "modId": this.modId,
-            "fieldData": fields_processed
-        }
-
-        // Check if there's been any edited portal information
-        let portals = this.portals.filter(a => portalFilter(a))
-        if (portals) {
-            obj["portalData"] = {}
-            for (let portal of portals) {
-                obj["portalData"][portal.name] = portal.records.filter(a => portalRowFilter(a)).map(record => {
-                    return record.toObject(portalFieldFilter)
-                })
-            }
-        }
-        return obj
-    }
-}
-
-export class LayoutRecord extends RecordBase {
-    portals: Portal[];
-
-    constructor(layout, recordId, modId = recordId, fieldData = {}, portalData = null) {
-        super(layout, recordId, modId);
-        this.fields = this.processFieldData(fieldData)
-        this.portals = []
-        if (portalData) {
-            this.processPortalData(portalData)
-        }
-    }
 }
 
 export class Field {
@@ -1924,7 +1923,28 @@ export class Field {
         return this._value
     }
 
-    upload(buffer: Buffer, filename: string, mime: string): Promise<void | FMError> {
+    get string(): string {
+        if (typeof this._value === "string") {
+            return this._value
+        }
+        throw "Field value is not a string"
+    }
+
+    get date(): Date {
+        if (this._value instanceof Date) {
+            return this._value
+        }
+        throw "Field value is not a date"
+    }
+
+    get number(): number {
+        if (typeof this._value === "number") {
+            return this._value
+        }
+        throw "Field value is not a number"
+    }
+
+    upload(buffer: Buffer, filename: string, mime: string): Promise<void> {
         let trace = new Error()
         if (this.metadata.result !== "container") throw "Cannot upload a file to the field; " + this.id + " (not a container field)"
         return new Promise(async (resolve, reject) => {
@@ -1985,11 +2005,11 @@ export class Field {
 }
 
 export class Portal {
-    readonly record: RecordBase;
+    readonly record: LayoutRecord;
     readonly name: string;
     public records: PortalRecord[];
 
-    constructor(record: RecordBase, name: string) {
+    constructor(record: LayoutRecord, name: string) {
         this.record = record
         this.name = name
     }
@@ -2126,11 +2146,11 @@ export class RecordGetRange extends RecordGetOperation {
     /**
      * @deprecated in favour of .fetch()
      */
-    run(extraBody: extraBodyOptions = {}): Promise<RecordBase[]> {
+    run(extraBody: extraBodyOptions = {}): Promise<LayoutRecord[]> {
         return this.fetch(extraBody)
     }
 
-    fetch(extraBody: extraBodyOptions = {}): Promise<RecordBase[]> {
+    fetch(extraBody: extraBodyOptions = {}): Promise<LayoutRecord[]> {
         let trace = new Error()
         return new Promise((resolve, reject) => {
             // console.log(this.#toObject())
@@ -2163,8 +2183,10 @@ export class RecordGetRange extends RecordGetOperation {
 export class Find extends RecordGetOperation {
     protected queries: object[]
 
-    constructor(layout) {
+    constructor(layout, start = 0, limit = 100) {
         super(layout)
+        this.setOffset(start)
+        this.setLimit(limit)
         this.queries = []
     }
 
@@ -2204,7 +2226,7 @@ export class Find extends RecordGetOperation {
         return this.fetch()
     }
 
-    fetch(): Promise<RecordBase[]> {
+    fetch(): Promise<LayoutRecord[]> {
         let trace = new Error()
         return new Promise((resolve, reject) => {
             // console.log(this.#toObject())