@jd-data-limited/easy-fm 3.2.7 → 4.0.0

package/src/records/layoutRecord.ts

@@ -1,23 +1,32 @@
 /*
- * Copyright (c) 2023. See LICENSE file for more information
+ * Copyright (c) 2023-2024. See LICENSE file for more information
  */
 
 import {extraBodyOptions, recordObject} from "../types.js";
 import {RecordBase} from "./recordBase.js";
 import {PortalRecord} from "./portalRecord.js";
 import {Portal} from "./portal.js";
-import {PortalInterface} from "../layouts/layoutInterface.js";
+import {LayoutInterface} from "../layouts/layoutInterface.js";
 import {FMError} from "../FMError.js";
-import {RecordFieldsMap} from "../layouts/recordFieldsMap";
-import {LayoutRecordBase} from "./layoutRecordBase";
+import {LayoutRecordBase} from "./layoutRecordBase.js";
+import {ApiRecordResponseObj} from "../models/apiResults.js";
+import {LayoutBase} from "../layouts/layoutBase.js"
 
-export class LayoutRecord<T extends RecordFieldsMap, P extends PortalInterface> extends RecordBase<T> implements LayoutRecordBase {
+export class LayoutRecord<LAYOUT extends LayoutInterface, PORTALS_TO_INCLUDE = string> extends RecordBase<LAYOUT["fields"]> implements LayoutRecordBase {
     // @ts-ignore
-    portals: P = {}
-
-    constructor(layout, recordId, modId = recordId, fieldData = {}, portalData = null) {
+    portals: Pick<LAYOUT["portals"], PORTALS_TO_INCLUDE> = {}
+    private readonly portalsToInclude: PORTALS_TO_INCLUDE[]
+
+    constructor(
+        layout: LayoutBase,
+        recordId: number | string,
+        modId = recordId,
+        fieldData: Record<string, string | number> = {},
+        portalData = null, portalsToInclude: PORTALS_TO_INCLUDE[] = [])
+    {
         super(layout, recordId, modId);
         this.processFieldData(fieldData)
+        this.portalsToInclude = portalsToInclude
         if (portalData) {
             this.processPortalData(portalData)
         }
@@ -27,77 +36,68 @@ export class LayoutRecord<T extends RecordFieldsMap, P extends PortalInterface>
         return Object.values(this.portals)
     }
 
-    commit(extraBody: extraBodyOptions = {}): Promise<this> {
-        let trace = new Error()
-        return new Promise(async (resolve, reject) => {
-            let data = this.toObject()
-            delete data.recordId
-            delete data.modId
-
-            if (extraBody.scripts?.after) {
-                data["script"] = extraBody.scripts.after.name
-                if (extraBody.scripts.after.parameter) data["script.param"] = extraBody.scripts.after.parameter
-            }
-            if (extraBody.scripts?.prerequest) {
-                data["script.prerequest"] = extraBody.scripts.after.name
-                if (extraBody.scripts.prerequest.parameter) data["script.prerequest.param"] = extraBody.scripts.prerequest.parameter
-            }
-            if (extraBody.scripts?.presort) {
-                data["script.presort"] = extraBody.scripts.presort.name
-                if (extraBody.scripts.presort.parameter) data["script.presort.param"] = extraBody.scripts.presort.parameter
-            }
+    async commit(extraBody: extraBodyOptions = {}): Promise<this> {
+        let data = this.toObject()
+        delete data.recordId
+        delete data.modId
 
-            if (this.recordId === -1) {
-                // This is a new LayoutRecord
+        if (extraBody.scripts?.after) {
+            data["script"] = extraBody.scripts.after.name
+            if (extraBody.scripts.after.parameter) data["script.param"] = extraBody.scripts.after.parameter
+        }
+        if (extraBody.scripts?.prerequest) {
+            data["script.prerequest"] = extraBody.scripts.after.name
+            if (extraBody.scripts.prerequest.parameter) data["script.prerequest.param"] = extraBody.scripts.prerequest.parameter
+        }
+        if (extraBody.scripts?.presort) {
+            data["script.presort"] = extraBody.scripts.presort.name
+            if (extraBody.scripts.presort.parameter) data["script.presort.param"] = extraBody.scripts.presort.parameter
+        }
 
-                this.layout.database.apiRequest(`${this.layout.endpoint}/records`, {
+        if (this.recordId === -1) {
+            // This is a new LayoutRecord
+             let res = await this.layout.database.apiRequest<{ recordId: string, modId: string }>(`${this.layout.endpoint}/records`, {
                     port: 443,
                     method: "POST",
                     body: JSON.stringify(data)
                 })
-                    .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.recordId = parseInt(res.response.recordId)
-                            this.modId = parseInt(res.response.modId)
-                            resolve(this)
-                        }
-                        else {
-                            reject(new FMError(res.messages[0].code, res.status, res, trace))
-                        }
-                    })
-                    .catch(e => {
-                        reject(e)
-                    })
-
-                return
-            }
 
-            // for (let item of Object.keys(data)) extraBody[item] = data[item]
-            this.layout.database.apiRequest(this.endpoint, {
-                port: 443,
-                method: "PATCH",
-                body: JSON.stringify(data)
-            })
-                .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.modId = res.response.modId
-                        this._onSave()
-                        resolve(this)
-                    }
-                    else {
-                        reject(new FMError(res.messages[0].code, res.status, res, trace))
-                    }
-                })
-                .catch(e => {
-                    reject(e)
-                })
+                if (typeof res.response.scriptError !== "undefined" && res.response.scriptError !== '0') {
+                    throw new FMError(res.response.scriptError, res.httpStatus, res)
+                }
+                else if (res.messages[0].code === "0") {
+                    this.recordId = parseInt(res.response.recordId)
+                    this.modId = parseInt(res.response.modId)
+                    return this
+                }
+                else {
+                    throw new FMError(res.messages[0].code, res.httpStatus, res)
+                }
+        }
+
+        // for (let item of Object.keys(data)) extraBody[item] = data[item]
+        let res = await this.layout.database.apiRequest<{
+            modId: string, newPortalRecordInfo: {
+                tableName: string,
+                recordId: string,
+                modId: string
+            }[]
+        }>(this.endpoint, {
+            port: 443,
+            method: "PATCH",
+            body: JSON.stringify(data)
         })
+        if (typeof res.response.scriptError !== "undefined" && res.response.scriptError !== '0') {
+            throw new FMError(res.response.scriptError, res.httpStatus, res)
+        }
+        else if (res.messages[0].code === "0") {
+            this.modId = +res.response.modId
+            this._onSave()
+            return this
+        }
+        else {
+            throw new FMError(res.messages[0].code, res.httpStatus, res)
+        }
     }
 
     protected processPortalData(portalData): void {
@@ -115,92 +115,68 @@ export class LayoutRecord<T extends RecordFieldsMap, P extends PortalInterface>
         }
     }
 
-    get(): Promise<this> {
+    async 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.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)
-                })
+        if (!this.layout.metadata) await this.layout.getLayoutMeta()
+        let res = await this.layout.database.apiRequest<ApiRecordResponseObj>(this.endpoint, {
+            port: 443,
+            method: "GET"
         })
+
+        if (res.messages[0].code === "0") {
+            // console.log(res, res.response.data)
+            this.modId = +res.response.data[0].modId
+            this.processFieldData(res.response.data[0].fieldData)
+            this.portalData = []
+            if (res.response.data[0].portalData) this.processPortalData(res.response.data[0].portalData)
+            return this
+        }
     }
 
     getPortal(portal) {
         return this.portalsArray.find(p => p.name === portal)
     }
 
-    duplicate(): Promise<LayoutRecord<T,P>> {
+    async duplicate(): Promise<LayoutRecord<LAYOUT>> {
         let trace = new Error()
-        return new Promise(async (resolve, reject) => {
-            this.layout.database.apiRequest(this.endpoint, {
-                port: 443,
-                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") {
-                        let data = this.toObject((a) => true, (a) => true, (a) => false, (a) => false)
-                        let _res = new LayoutRecord<T,P>(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))
-                    }
-                })
-                .catch(e => {
-                    reject(e)
-                })
+        let res = await this.layout.database.apiRequest<{recordId: string, modId: string}>(this.endpoint, {
+            port: 443,
+            method: "POST"
         })
+        if (typeof res.response.scriptError !== "undefined" && res.response.scriptError !== '0') {
+            throw new FMError(res.response.scriptError, res.httpStatus, 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<LAYOUT>(this.layout, res.response.recordId, res.response.modId, data.fieldData, data.portalData)
+
+            this.emit("duplicated")
+            return _res
+        }
+        else {
+            throw new FMError(res.messages[0].code, res.httpStatus, res, trace)
+        }
     }
 
-    delete(): Promise<void> {
-        let trace = new Error()
-        return new Promise(async (resolve, reject) => {
-            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))
-                    }
-                    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)
-                })
+    async delete(): Promise<void> {
+        let res = await this.layout.database.apiRequest(this.endpoint, {
+            port: 443,
+            method: "DELETE"
         })
+        console.log(res)
+        if (typeof res.response?.scriptError !== "undefined" && res.response?.scriptError !== '0') {
+            throw new FMError(res.response.scriptError, res.httpStatus, res)
+        }
+        else if (res.messages[0].code === "0") {
+            this.emit("deleted")
+            return
+        }
+        else {
+            throw new FMError(res.messages[0].code, res.httpStatus, res)
+        }
     }
 
     toObject(filter: (a) => any = (a) => a.edited, portalFilter: (a) => any = (a) => a.records.find(record => record.edited), portalRowFilter: (a) => any = (a) => a.edited, portalFieldFilter: (a) => any = (a) => a.edited): recordObject {

package/src/records/portal.d.ts

@@ -1,11 +1,12 @@
 import { PortalRecord } from "./portalRecord.js";
-import { RecordFieldsMap } from "../layouts/recordFieldsMap";
-import { PortalBase } from "./portalBase";
-import { LayoutRecord } from "./layoutRecord";
+import { RecordFieldsMap } from "../layouts/recordFieldsMap.js";
+import { PortalBase } from "./portalBase.js";
+import { LayoutRecord } from "./layoutRecord.js";
+import { LayoutInterface } from "../layouts/layoutInterface.js";
 export declare class Portal<T extends RecordFieldsMap> implements PortalBase<T> {
-    readonly record: LayoutRecord<any, any>;
+    readonly record: LayoutRecord<LayoutInterface>;
     readonly name: string;
     records: PortalRecord<T>[];
-    constructor(record: LayoutRecord<any, any>, name: string);
+    constructor(record: LayoutRecord<LayoutInterface, any>, name: string);
     create(): PortalRecord<T>;
 }

package/src/records/portal.js

@@ -1,8 +1,11 @@
 /*
- * Copyright (c) 2023. See LICENSE file for more information
+ * Copyright (c) 2023-2024. See LICENSE file for more information
  */
 import { PortalRecord } from "./portalRecord.js";
 export class Portal {
+    record;
+    name;
+    records;
     constructor(record, name) {
         this.record = record;
         this.name = name;

package/src/records/portal.ts

@@ -1,19 +1,19 @@
 /*
- * Copyright (c) 2023. See LICENSE file for more information
+ * Copyright (c) 2023-2024. See LICENSE file for more information
  */
 
 import {PortalRecord} from "./portalRecord.js";
-import {RecordFieldsMap} from "../layouts/recordFieldsMap";
-import {PortalBase} from "./portalBase";
-import {LayoutRecordBase} from "./layoutRecordBase";
-import {LayoutRecord} from "./layoutRecord";
+import {RecordFieldsMap} from "../layouts/recordFieldsMap.js";
+import {PortalBase} from "./portalBase.js";
+import {LayoutRecord} from "./layoutRecord.js";
+import {LayoutInterface} from "../layouts/layoutInterface.js";
 
 export class Portal<T extends RecordFieldsMap> implements PortalBase<T> {
-    readonly record: LayoutRecord<any, any>;
+    readonly record: LayoutRecord<LayoutInterface>;
     readonly name: string;
     public records: PortalRecord<T>[];
 
-    constructor(record: LayoutRecord<any, any>, name: string) {
+    constructor(record: LayoutRecord<LayoutInterface, any>, name: string) {
         this.record = record
         this.name = name
     }

package/src/records/portalBase.d.ts

@@ -1,8 +1,9 @@
-import { RecordFieldsMap } from "../layouts/recordFieldsMap";
-import { RecordBase } from "./recordBase";
-import { LayoutRecord } from "./layoutRecord";
+import { RecordFieldsMap } from "../layouts/recordFieldsMap.js";
+import { RecordBase } from "./recordBase.js";
+import { LayoutRecord } from "./layoutRecord.js";
+import { LayoutInterface } from "../layouts/layoutInterface.js";
 export interface PortalBase<T extends RecordFieldsMap> {
-    readonly record: LayoutRecord<any, any>;
+    readonly record: LayoutRecord<LayoutInterface>;
     readonly name: string;
     records: RecordBase<T>[];
 }

package/src/records/portalBase.js

@@ -1,4 +1,4 @@
 /*
- * Copyright (c) 2023. See LICENSE file for more information
+ * Copyright (c) 2023-2024. See LICENSE file for more information
  */
 export {};

package/src/records/portalBase.ts

@@ -1,14 +1,14 @@
 /*
- * Copyright (c) 2023. See LICENSE file for more information
+ * Copyright (c) 2023-2024. See LICENSE file for more information
  */
 
-import {RecordFieldsMap} from "../layouts/recordFieldsMap";
-import {LayoutRecordBase} from "./layoutRecordBase";
-import {RecordBase} from "./recordBase";
-import {LayoutRecord} from "./layoutRecord";
+import {RecordFieldsMap} from "../layouts/recordFieldsMap.js";
+import {RecordBase} from "./recordBase.js";
+import {LayoutRecord} from "./layoutRecord.js";
+import {LayoutInterface} from "../layouts/layoutInterface.js";
 
 export interface PortalBase<T extends RecordFieldsMap> {
-    readonly record: LayoutRecord<any, any>
+    readonly record: LayoutRecord<LayoutInterface>
     readonly name: string
     records: RecordBase<T>[]
 }

package/src/records/portalRecord.d.ts

@@ -1,13 +1,13 @@
-import { RecordBase, RecordTypes } from "./recordBase.js";
-import { extraBodyOptions } from "../types.js";
-import { RecordFieldsMap } from "../layouts/recordFieldsMap";
-import { PortalBase } from "./portalBase";
+import { RecordBase } from "./recordBase.js";
+import { extraBodyOptions, RecordTypes } from "../types.js";
+import { RecordFieldsMap } from "../layouts/recordFieldsMap.js";
+import { PortalBase } from "./portalBase.js";
 export declare class PortalRecord<T extends RecordFieldsMap> extends RecordBase<T> {
     readonly portal: PortalBase<T>;
     readonly type = RecordTypes.PORTAL;
     constructor(record: any, portal: any, recordId: any, modId?: any, fieldData?: {});
     _onSave(): void;
-    commit(extraBody?: extraBodyOptions): Promise<import("./layoutRecord.js").LayoutRecord<any, any>>;
+    commit(extraBody?: extraBodyOptions): Promise<import("./layoutRecord.js").LayoutRecord<import("../index.js").LayoutInterface, string>>;
     toObject(fieldFilter: any): any;
-    getField(field: any): import("./field.js").Field<import("./field.js").FieldValue>;
+    getField(field: any): import("./fieldBase.js").FieldBase<import("./fieldBase.js").FieldValue>;
 }

package/src/records/portalRecord.js

@@ -1,11 +1,13 @@
 /*
- * Copyright (c) 2023. See LICENSE file for more information
+ * Copyright (c) 2023-2024. See LICENSE file for more information
  */
-import { RecordBase, RecordTypes } from "./recordBase.js";
+import { RecordBase } from "./recordBase.js";
+import { RecordTypes } from "../types.js";
 export class PortalRecord extends RecordBase {
+    portal;
+    type = RecordTypes.PORTAL;
     constructor(record, portal, recordId, modId = recordId, fieldData = {}) {
         super(record.layout, recordId, modId);
-        this.type = RecordTypes.PORTAL;
         this.portal = portal;
         this.processFieldData(fieldData);
     }

package/src/records/portalRecord.ts

@@ -1,12 +1,12 @@
 /*
- * Copyright (c) 2023. See LICENSE file for more information
+ * Copyright (c) 2023-2024. See LICENSE file for more information
  */
 
-import {RecordBase, RecordTypes} from "./recordBase.js";
-import {extraBodyOptions, recordObject} from "../types.js";
+import {RecordBase} from "./recordBase.js";
+import {extraBodyOptions, recordObject, RecordTypes} from "../types.js";
 
-import {RecordFieldsMap} from "../layouts/recordFieldsMap";
-import {PortalBase} from "./portalBase";
+import {RecordFieldsMap} from "../layouts/recordFieldsMap.js";
+import {PortalBase} from "./portalBase.js";
 
 export class PortalRecord<T extends RecordFieldsMap> extends RecordBase<T> {
     readonly portal: PortalBase<T>;

package/src/records/recordBase.d.ts

@@ -1,16 +1,11 @@
-/// <reference types="node" />
+/// <reference types="node" resolution-mode="require"/>
 import { EventEmitter } from "events";
-import { Field } from "./field.js";
-import { Layout } from "../layouts/layout.js";
-import { recordObject } from "../types.js";
-import { RecordFieldsMap } from "../layouts/recordFieldsMap";
-export declare enum RecordTypes {
-    UNKNOWN = 0,
-    LAYOUT = 1,
-    PORTAL = 2
-}
+import { FieldBase, FieldValue } from "./fieldBase.js";
+import { recordObject, RecordTypes } from "../types.js";
+import { RecordFieldsMap } from "../layouts/recordFieldsMap.js";
+import { LayoutBase } from "../layouts/layoutBase.js";
 export declare class RecordBase<T extends RecordFieldsMap> extends EventEmitter {
-    readonly layout: Layout<any>;
+    readonly layout: LayoutBase;
     readonly type: RecordTypes;
     recordId: number;
     modId: number;
@@ -19,7 +14,7 @@ export declare class RecordBase<T extends RecordFieldsMap> extends EventEmitter
     constructor(layout: any, recordId: any, modId?: any);
     get endpoint(): string;
     get edited(): boolean;
-    get fieldsArray(): Field<import("./field.js").FieldValue>[];
+    get fieldsArray(): FieldBase<FieldValue>[];
     protected processFieldData(fieldData: any): T;
     _onSave(): void;
     toObject(filter?: (a: any) => any, portalFilter?: (a: any) => any, portalRowFilter?: (a: any) => any, portalFieldFilter?: (a: any) => any): recordObject;

package/src/records/recordBase.js

@@ -1,19 +1,19 @@
 /*
- * Copyright (c) 2023. See LICENSE file for more information
+ * Copyright (c) 2023-2024. See LICENSE file for more information
  */
 import { EventEmitter } from "events";
 import * as moment from "moment";
-import { Field } from "./field.js";
-export var RecordTypes;
-(function (RecordTypes) {
-    RecordTypes[RecordTypes["UNKNOWN"] = 0] = "UNKNOWN";
-    RecordTypes[RecordTypes["LAYOUT"] = 1] = "LAYOUT";
-    RecordTypes[RecordTypes["PORTAL"] = 2] = "PORTAL";
-})(RecordTypes || (RecordTypes = {}));
+import { FieldBase } from "./fieldBase.js";
+import { RecordTypes } from "../types.js";
 export class RecordBase extends EventEmitter {
+    layout;
+    type = RecordTypes.UNKNOWN;
+    recordId;
+    modId;
+    fields;
+    portalData;
     constructor(layout, recordId, modId = recordId) {
         super();
-        this.type = RecordTypes.UNKNOWN;
         this.layout = layout;
         this.recordId = recordId;
         this.modId = modId;
@@ -30,7 +30,7 @@ export class RecordBase extends EventEmitter {
     processFieldData(fieldData) {
         let fields = {};
         for (let key of Object.keys(fieldData)) {
-            let _field = new Field(this, key, fieldData[key]);
+            let _field = new FieldBase(this, key, fieldData[key]);
             if (!!fieldData[key]) {
                 if (_field.metadata.result === "timeStamp") {
                     // @ts-ignore
@@ -69,7 +69,8 @@ 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.fieldsArray.filter(field => filter(field))) {
+        let field;
+        for (field of this.fieldsArray.filter(field => filter(field))) {
             let value = field.value;
             if (value instanceof Date) {
                 // @ts-ignore

package/src/records/recordBase.ts

@@ -1,22 +1,16 @@
 /*
- * Copyright (c) 2023. See LICENSE file for more information
+ * Copyright (c) 2023-2024. See LICENSE file for more information
  */
 
 import {EventEmitter} from "events";
 import * as moment from "moment";
-import {Field} from "./field.js";
-import {Layout} from "../layouts/layout.js";
-import {recordObject} from "../types.js";
-import {RecordFieldsMap} from "../layouts/recordFieldsMap";
-
-export enum RecordTypes {
-    UNKNOWN,
-    LAYOUT,
-    PORTAL
-}
+import {FieldBase, FieldValue} from "./fieldBase.js";
+import {recordObject, RecordTypes} from "../types.js";
+import {RecordFieldsMap} from "../layouts/recordFieldsMap.js";
+import {LayoutBase} from "../layouts/layoutBase.js";
 
 export class RecordBase<T extends RecordFieldsMap> extends EventEmitter {
-    readonly layout: Layout<any>;
+    readonly layout: LayoutBase;
     readonly type: RecordTypes = RecordTypes.UNKNOWN;
     public recordId: number;
     modId: number;
@@ -38,7 +32,7 @@ export class RecordBase<T extends RecordFieldsMap> extends EventEmitter {
         return !!this.fieldsArray.find(i => i.edited)
     }
 
-    get fieldsArray() {
+    get fieldsArray(): FieldBase<FieldValue>[] {
         return Object.values(this.fields)
     }
 
@@ -46,7 +40,7 @@ export class RecordBase<T extends RecordFieldsMap> extends EventEmitter {
         let fields: RecordFieldsMap = {}
 
         for (let key of Object.keys(fieldData)) {
-            let _field = new Field(this, key, fieldData[key])
+            let _field = new FieldBase(this, key, fieldData[key])
             if (!!fieldData[key]) {
                 if (_field.metadata.result === "timeStamp") {
                     // @ts-ignore
@@ -91,7 +85,8 @@ export class RecordBase<T extends RecordFieldsMap> extends EventEmitter {
              portalFieldFilter = (a) => a.edited
     ): recordObject {
         let fields_processed = {}
-        for (let field of this.fieldsArray.filter(field => filter(field))) {
+        let field: FieldBase<FieldValue>
+        for (field of this.fieldsArray.filter(field => filter(field))) {
             let value = field.value
             if (value instanceof Date) {
                 // @ts-ignore