@jd-data-limited/easy-fm 3.2.8 → 4.0.1

package/src/records/getOperations/recordGetOperation.js

@@ -1,46 +1,157 @@
 /*
- * Copyright (c) 2023. See LICENSE file for more information
+ * Copyright (c) 2023-2024. See LICENSE file for more information
  */
+import { LayoutRecord } from "../layoutRecord.js";
+import { FMError } from "../../FMError.js";
 export class RecordGetOperation {
     layout;
     limit = 100;
-    scripts;
-    sort;
-    limitPortals = [];
-    offset = 0;
-    constructor(layout) {
+    scriptData = {};
+    sortData = [];
+    portals;
+    offset = 1;
+    queries = [];
+    constructor(layout, options) {
         this.layout = layout;
-        this.scripts = {
-            "script": null,
-            "script.prerequeset": null,
-            "script.presort": null // Runs before the sort
+        this.sortData = [];
+        this.portals = options.portals;
+        this.offset = options.offset || 1; // Offset refers to the starting record. offset 1 is the same as no offset.
+        this.limit = options.limit || 100;
+    }
+    get isFindRequest() {
+        return this.queries.length !== 0;
+    }
+    generateParamsBody(offset, limit) {
+        const params = {
+            limit: limit.toString(),
+            offset: offset.toString(),
         };
-        this.sort = [];
-    }
-    /*
-    addToPortalLimit() will adjust the results of the get request so that if a layout has multiple portals in it,
-    only data from the specified ones will be read. This may help reduce load on your FileMaker API
-    */
-    addToPortalLimit(portal, offset = 0, limit = 100) {
-        if (offset < 0)
-            throw "Portal offset cannot be less than 0";
-        this.limitPortals.push({ portalName: portal.name, offset, limit });
-        return this;
+        if (this.sortData.length !== 0)
+            params.sort = JSON.stringify(this.sortData);
+        if (this.scriptData.after)
+            params["script"] = this.scriptData.after.name;
+        if (this.scriptData.after?.parameter)
+            params["script.param"] = this.scriptData.after.parameter;
+        if (this.scriptData.presort)
+            params["script.presort"] = this.scriptData.after.name;
+        if (this.scriptData.presort?.parameter)
+            params["script.presort.param"] = this.scriptData.after.parameter;
+        if (this.scriptData.prerequest)
+            params["script.prerequest"] = this.scriptData.after.name;
+        if (this.scriptData.prerequest?.parameter)
+            params["script.prerequest.param"] = this.scriptData.after.parameter;
+        if (this.queries.length !== 0)
+            params["query"] = this.queries;
+        let portals = Object.keys(this.portals);
+        params["portal"] = portals;
+        for (let portal of portals) {
+            params[`offset.${portal}`] = this.portals[portal].offset;
+            params[`limit.${portal}`] = this.portals[portal].limit;
+        }
+        return params;
     }
-    setLimit(limit) {
-        if (limit < 1)
-            throw "Record limit too low";
-        this.limit = limit;
+    generateParamsURL(offset, limit) {
+        const params = new URLSearchParams({
+            _limit: limit.toString(),
+            _offset: offset.toString(),
+        });
+        if (this.sortData.length !== 0)
+            params.set("_sort", JSON.stringify(this.sortData));
+        if (this.scriptData.after)
+            params.set("script", this.scriptData.after.name);
+        if (this.scriptData.after?.parameter)
+            params.set("script.param", this.scriptData.after.parameter);
+        if (this.scriptData.presort)
+            params.set("script.presort", this.scriptData.after.name);
+        if (this.scriptData.presort?.parameter)
+            params.set("script.presort.param", this.scriptData.after.parameter);
+        if (this.scriptData.prerequest)
+            params.set("script.prerequest", this.scriptData.after.name);
+        if (this.scriptData.prerequest?.parameter)
+            params.set("script.prerequest.param", this.scriptData.after.parameter);
+        let portals = Object.keys(this.portals);
+        for (let portal of portals) {
+            params.set(`_offset.${portal}`, this.portals[portal].limit.toString());
+            params.set(`_offset.${portal}`, this.portals[portal].offset.toString());
+        }
+        params.set('portal', JSON.stringify(portals));
+        return params;
+    }
+    scripts(scripts) {
+        this.scriptData = scripts;
         return this;
     }
-    addSort(fieldName, sortOrder) {
-        this.sort.push({ fieldName, sortOrder });
+    sort(fieldName, sortOrder) {
+        this.sortData.push({ fieldName, sortOrder });
         return this;
     }
-    setOffset(offset) {
-        if (offset < 0)
-            throw "Record offset too low";
-        this.offset = offset;
+    addRequest(query) {
+        this.queries.push(query);
         return this;
     }
+    fetch() {
+        return this.performFind(this.offset, this.limit);
+    }
+    async performFind(offset, limit) {
+        let trace = new Error();
+        await this.layout.getLayoutMeta();
+        const is_find = this.isFindRequest;
+        let endpoint = this.layout.endpoint + (is_find ? "/_find" : "/records");
+        if (!is_find)
+            endpoint += "?" + new URLSearchParams(this.generateParamsURL(offset, limit)).toString();
+        const reqData = {
+            // port: 443,
+            method: is_find ? "POST" : "GET",
+            body: is_find ? JSON.stringify(this.generateParamsBody(offset, limit)) : undefined,
+        };
+        let res = await this.layout.database.apiRequest(endpoint, reqData);
+        if (res.messages[0].code === "0") {
+            // console.log("RESOLVING")
+            if (!this.layout.metadata)
+                await this.layout.getLayoutMeta();
+            return res.response.data.map(item => {
+                return new LayoutRecord(this.layout, item.recordId, item.modId, item.fieldData, item.portalData);
+            });
+        }
+        else if (res.messages[0].code == "401") {
+            // No records found, so return empty set
+            return [];
+        }
+        else {
+            throw new FMError(res.messages[0].code, res.httpStatus, res, trace);
+        }
+    }
+    [Symbol.asyncIterator]() {
+        let nextOffset = this.offset;
+        let startOffset = JSON.parse(JSON.stringify(this.offset));
+        let limit = this.limit;
+        let exit_after_last_record = false;
+        let records = [];
+        const fetch = async () => {
+            const theoretical_limit = (limit - nextOffset) + startOffset;
+            if (theoretical_limit === 0) {
+                exit_after_last_record = true;
+                records = [];
+                return;
+            }
+            records = await this.performFind(nextOffset, theoretical_limit < 100 ? theoretical_limit : 100);
+            nextOffset += 100;
+            if (records.length < 100)
+                exit_after_last_record = true;
+        };
+        return {
+            next: async () => {
+                if (records.length === 0 && !exit_after_last_record) {
+                    await fetch();
+                }
+                if (records.length === 0 && exit_after_last_record) {
+                    return { done: true, value: undefined };
+                }
+                else {
+                    const record = records.shift();
+                    return { done: false, value: record };
+                }
+            }
+        };
+    }
 }

package/src/records/getOperations/recordGetOperation.ts

@@ -1,54 +1,196 @@
 /*
- * Copyright (c) 2023. See LICENSE file for more information
+ * Copyright (c) 2023-2024. See LICENSE file for more information
  */
 
 import {LayoutInterface} from "../../layouts/layoutInterface.js";
-import {Portal} from "../portal.js";
-import {limitPortalsInterface} from "../../types.js";
+import {ScriptRequestData} from "../../types.js";
 import {LayoutBase} from "../../layouts/layoutBase.js"
+import {LayoutRecord} from "../layoutRecord.js";
+import {ApiRecordResponseObj} from "../../models/apiResults.js";
+import {FMError} from "../../FMError.js";
 
-export class RecordGetOperation<T extends LayoutInterface> {
+export type SortOrder = "ascend" | "descend"
+export type FindRequest = {
+    [key: string]: string,
+    omit?: "true" | "false"
+}
+export type PortalRequest = {
+    name: string,
+}
+
+type PortalData<T extends LayoutInterface> = {
+    [key in keyof T["portals"]]: {
+        limit: number,
+        offset: number
+    }
+}
+export type GetOperationOptions<T extends LayoutInterface> = {
+    portals: Partial<PortalData<T>>,
+    limit?: number,
+    offset?: number
+}
+
+export class RecordGetOperation<T extends LayoutInterface, OPTIONS extends GetOperationOptions<T>> {
     protected layout: LayoutBase
     protected limit: number = 100
-    protected scripts: object
-    protected sort: object[]
-    protected limitPortals: limitPortalsInterface[] = []
-    protected offset: number = 0
+    protected scriptData: ScriptRequestData = {}
+    protected sortData: { fieldName: string, sortOrder: SortOrder }[] = []
+    protected portals: Partial<PortalData<T>>
+    protected offset: number = 1
+    protected queries: FindRequest[] = []
 
-    constructor(layout: LayoutBase) {
+    constructor(layout: LayoutBase, options: OPTIONS) {
         this.layout = layout
-        this.scripts = {
-            "script": null, // Runs after everything
-            "script.prerequeset": null, // Runs before the request
-            "script.presort": null // Runs before the sort
+        this.sortData = []
+        this.portals = options.portals
+        this.offset = options.offset || 1 // Offset refers to the starting record. offset 1 is the same as no offset.
+        this.limit = options.limit || 100
+    }
+
+    get isFindRequest() {
+        return this.queries.length !== 0
+    }
+
+    protected generateParamsBody(offset: number, limit: number) {
+        const params: {[key: string]: any} = {
+            limit: limit.toString(),
+            offset: offset.toString(),
         }
-        this.sort = []
+        if (this.sortData.length !== 0) params.sort = JSON.stringify(this.sortData)
+
+
+        if (this.scriptData.after) params["script"] = this.scriptData.after.name
+        if (this.scriptData.after?.parameter) params["script.param"] = this.scriptData.after.parameter
+
+        if (this.scriptData.presort) params["script.presort"] = this.scriptData.after.name
+        if (this.scriptData.presort?.parameter) params["script.presort.param"] = this.scriptData.after.parameter
+
+        if (this.scriptData.prerequest) params["script.prerequest"] = this.scriptData.after.name
+        if (this.scriptData.prerequest?.parameter) params["script.prerequest.param"] = this.scriptData.after.parameter
+
+        if (this.queries.length !== 0) params["query"] = this.queries
+
+        let portals = Object.keys(this.portals)
+        params["portal"] = portals
+        for (let portal of portals) {
+            params[`offset.${portal}`] = this.portals[portal].offset
+            params[`limit.${portal}`] = this.portals[portal].limit
+        }
+
+        return params
     }
+    protected generateParamsURL(offset: number, limit: number) {
+        const params = new URLSearchParams({
+            _limit: limit.toString(),
+            _offset: offset.toString(),
+        })
+        if (this.sortData.length !== 0) params.set("_sort", JSON.stringify(this.sortData))
 
-    /*
-    addToPortalLimit() will adjust the results of the get request so that if a layout has multiple portals in it,
-    only data from the specified ones will be read. This may help reduce load on your FileMaker API
-    */
-    addToPortalLimit(portal: Portal<any>, offset = 0, limit = 100) {
-        if (offset < 0) throw "Portal offset cannot be less than 0"
-        this.limitPortals.push({portalName: portal.name, offset, limit})
-        return this
+        if (this.scriptData.after) params.set("script", this.scriptData.after.name)
+        if (this.scriptData.after?.parameter) params.set("script.param", this.scriptData.after.parameter)
+
+        if (this.scriptData.presort) params.set("script.presort", this.scriptData.after.name)
+        if (this.scriptData.presort?.parameter) params.set("script.presort.param", this.scriptData.after.parameter)
+
+        if (this.scriptData.prerequest) params.set("script.prerequest", this.scriptData.after.name)
+        if (this.scriptData.prerequest?.parameter) params.set("script.prerequest.param", this.scriptData.after.parameter)
+
+        let portals = Object.keys(this.portals)
+        for (let portal of portals) {
+            params.set(`_offset.${portal}`, this.portals[portal].limit.toString())
+            params.set(`_offset.${portal}`, this.portals[portal].offset.toString())
+        }
+        params.set('portal', JSON.stringify(portals))
+
+        return params
     }
 
-    setLimit(limit: number) {
-        if (limit < 1) throw "Record limit too low"
-        this.limit = limit
+    scripts(scripts: ScriptRequestData) {
+        this.scriptData = scripts;
         return this
     }
 
-    addSort(fieldName, sortOrder) {
-        this.sort.push({fieldName, sortOrder})
+    sort(fieldName: string, sortOrder: SortOrder) {
+        this.sortData.push({fieldName, sortOrder})
         return this
     }
 
-    setOffset(offset: number) {
-        if (offset < 0) throw "Record offset too low"
-        this.offset = offset
+    addRequest(query: FindRequest) {
+        this.queries.push(query)
         return this
     }
+
+    fetch() {
+        return this.performFind(this.offset, this.limit)
+    }
+
+    private async performFind(offset: number, limit: number): Promise<LayoutRecord<T, keyof OPTIONS["portals"]>[]> {
+        let trace = new Error()
+        await this.layout.getLayoutMeta()
+
+        const is_find = this.isFindRequest
+        let endpoint = this.layout.endpoint + (is_find ? "/_find" : "/records")
+        if (!is_find) endpoint += "?" + new URLSearchParams(this.generateParamsURL(offset, limit)).toString()
+        const reqData = {
+            // port: 443,
+            method: is_find ? "POST" : "GET",
+            body: is_find ? JSON.stringify(this.generateParamsBody(offset, limit)) : undefined,
+        }
+
+        let res = await this.layout.database.apiRequest<ApiRecordResponseObj>(
+            endpoint,
+            reqData
+        )
+        if (res.messages[0].code === "0") {
+            // console.log("RESOLVING")
+            if (!this.layout.metadata) await this.layout.getLayoutMeta()
+            return res.response.data.map(item => {
+                return new LayoutRecord(this.layout, item.recordId, item.modId, item.fieldData, item.portalData)
+            })
+        }
+        else if (res.messages[0].code == "401") {
+            // No records found, so return empty set
+            return []
+        }
+        else {
+            throw new FMError(res.messages[0].code, res.httpStatus, res, trace)
+        }
+    }
+
+    [Symbol.asyncIterator]() {
+        let nextOffset = this.offset
+        let startOffset: number = JSON.parse(JSON.stringify(this.offset))
+        let limit = this.limit
+
+        let exit_after_last_record = false
+        let records: LayoutRecord<T, keyof OPTIONS["portals"]>[] = []
+
+        const fetch = async () => {
+            const theoretical_limit = (limit - nextOffset) + startOffset
+            if (theoretical_limit === 0) {
+                exit_after_last_record = true
+                records = []
+                return
+            }
+            records = await this.performFind(nextOffset, theoretical_limit < 100 ? theoretical_limit : 100);
+            nextOffset += 100;
+            if (records.length < 100) exit_after_last_record = true
+        }
+
+        return {
+            next: async () => {
+                if (records.length === 0 && !exit_after_last_record) {
+                    await fetch();
+                }
+
+                if (records.length === 0 && exit_after_last_record) {
+                    return {done: true, value: undefined};
+                }
+                else {
+                    const record = records.shift()
+                    return {done: false, value: record};
+                }
+            }
+        };
+    }
 }

package/src/records/layoutRecord.d.ts

@@ -1,18 +1,21 @@
-import { extraBodyOptions, recordObject } from "../types.js";
+import { extraBodyOptions } 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 { RecordFieldsMap } from "../layouts/recordFieldsMap";
-import { LayoutRecordBase } from "./layoutRecordBase";
-export declare class LayoutRecord<T extends RecordFieldsMap, P extends PortalInterface> extends RecordBase<T> implements LayoutRecordBase {
-    portals: P;
-    constructor(layout: any, recordId: any, modId?: any, fieldData?: {}, portalData?: any);
+import { LayoutInterface } from "../layouts/layoutInterface.js";
+import { LayoutRecordBase } from "./layoutRecordBase.js";
+import { ApiPortalData } from "../models/apiResults.js";
+import { LayoutBase } from "../layouts/layoutBase.js";
+import { FieldBase, FieldValue } from "./fieldBase.js";
+export declare class LayoutRecord<LAYOUT extends LayoutInterface, PORTALS_TO_INCLUDE = string> extends RecordBase<LAYOUT["fields"]> implements LayoutRecordBase {
+    portals: Pick<LAYOUT["portals"], PORTALS_TO_INCLUDE>;
+    private readonly portalsToInclude;
+    constructor(layout: LayoutBase, recordId: number | string, modId?: string | number, fieldData?: Record<string, string | number>, portalData?: ApiPortalData | null, portalsToInclude?: PORTALS_TO_INCLUDE[]);
     get portalsArray(): Portal<any>[];
     commit(extraBody?: extraBodyOptions): Promise<this>;
-    protected processPortalData(portalData: any): void;
+    protected processPortalData(portalData: ApiPortalData): void;
     get(): Promise<this>;
-    getPortal(portal: any): Portal<any>;
-    duplicate(): Promise<LayoutRecord<T, P>>;
+    duplicate(): Promise<LayoutRecord<LAYOUT>>;
     delete(): Promise<void>;
-    toObject(filter?: (a: any) => any, portalFilter?: (a: any) => any, portalRowFilter?: (a: any) => any, portalFieldFilter?: (a: any) => any): recordObject;
+    toObject(filter?: (a: FieldBase<FieldValue>) => any, portalFilter?: (a: Portal<any>) => any, portalRowFilter?: (a: PortalRecord<never>) => any, portalFieldFilter?: (a: FieldBase<FieldValue>) => any): Partial<Omit<import("../models/apiResults.js").ApiRowDataDef, "portalDataInfo">>;
 }

package/src/records/layoutRecord.js

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023. See LICENSE file for more information
+ * Copyright (c) 2023-2024. See LICENSE file for more information
  */
 import { RecordBase } from "./recordBase.js";
 import { PortalRecord } from "./portalRecord.js";
@@ -8,9 +8,11 @@ import { FMError } from "../FMError.js";
 export class LayoutRecord extends RecordBase {
     // @ts-ignore
     portals = {};
-    constructor(layout, recordId, modId = recordId, fieldData = {}, portalData = null) {
-        super(layout, recordId, modId);
+    portalsToInclude;
+    constructor(layout, recordId, modId = recordId, fieldData = {}, portalData = null, portalsToInclude = []) {
+        super(layout, parseInt(recordId), parseInt(modId));
         this.processFieldData(fieldData);
+        this.portalsToInclude = portalsToInclude;
         if (portalData) {
             this.processPortalData(portalData);
         }
@@ -81,7 +83,7 @@ export class LayoutRecord extends RecordBase {
                 let fieldData = item;
                 delete fieldData.recordId;
                 delete fieldData.modId;
-                return new PortalRecord(this, _portal, item.recordId, item.modId, fieldData);
+                return new PortalRecord(this, _portal, parseInt(item.recordId), parseInt(item.modId), fieldData);
             });
             // @ts-ignore
             this.portals[portalName] = _portal;
@@ -108,9 +110,6 @@ export class LayoutRecord extends RecordBase {
             return this;
         }
     }
-    getPortal(portal) {
-        return this.portalsArray.find(p => p.name === portal);
-    }
     async duplicate() {
         let trace = new Error();
         let res = await this.layout.database.apiRequest(this.endpoint, {
@@ -148,7 +147,7 @@ export class LayoutRecord extends RecordBase {
         }
     }
     toObject(filter = (a) => a.edited, portalFilter = (a) => a.records.find(record => record.edited), portalRowFilter = (a) => a.edited, portalFieldFilter = (a) => a.edited) {
-        let obj = super.toObject(filter, portalFilter, portalRowFilter, portalFieldFilter);
+        let obj = super.toObject(filter);
         // Check if there's been any edited portal information
         let portals = this.portalsArray.filter(a => portalFilter(a));
         if (portals) {

package/src/records/layoutRecord.ts

@@ -1,24 +1,33 @@
 /*
- * 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 {extraBodyOptions} 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 {ApiRecordResponseObj, ApiResultSetObj} from "../models/apiResults";
+import {LayoutRecordBase} from "./layoutRecordBase.js";
+import {ApiPortalData, ApiRecordResponseObj} from "../models/apiResults.js";
+import {LayoutBase} from "../layouts/layoutBase.js"
+import {FieldBase, FieldValue} from "./fieldBase.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) {
-        super(layout, recordId, modId);
+    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: ApiPortalData | null = null, portalsToInclude: PORTALS_TO_INCLUDE[] = [])
+    {
+        super(layout, parseInt(recordId as string), parseInt(modId as string));
         this.processFieldData(fieldData)
+        this.portalsToInclude = portalsToInclude
         if (portalData) {
             this.processPortalData(portalData)
         }
@@ -29,7 +38,7 @@ export class LayoutRecord<T extends RecordFieldsMap, P extends PortalInterface>
     }
 
     async commit(extraBody: extraBodyOptions = {}): Promise<this> {
-        let data = this.toObject()
+        let data: any = this.toObject()
         delete data.recordId
         delete data.modId
 
@@ -92,14 +101,14 @@ export class LayoutRecord<T extends RecordFieldsMap, P extends PortalInterface>
         }
     }
 
-    protected processPortalData(portalData): void {
+    protected processPortalData(portalData: ApiPortalData): void {
         for (let portalName of Object.keys(portalData)) {
             let _portal = new Portal(this, portalName)
             _portal.records = portalData[portalName].map(item => {
                 let fieldData = item;
                 delete fieldData.recordId;
                 delete fieldData.modId;
-                return new PortalRecord(this, _portal, item.recordId, item.modId, fieldData);
+                return new PortalRecord(this, _portal, parseInt(item.recordId as string), parseInt(item.modId as string), fieldData);
             })
 
             // @ts-ignore
@@ -128,11 +137,7 @@ export class LayoutRecord<T extends RecordFieldsMap, P extends PortalInterface>
         }
     }
 
-    getPortal(portal) {
-        return this.portalsArray.find(p => p.name === portal)
-    }
-
-    async duplicate(): Promise<LayoutRecord<T, P>> {
+    async duplicate(): Promise<LayoutRecord<LAYOUT>> {
         let trace = new Error()
         let res = await this.layout.database.apiRequest<{recordId: string, modId: string}>(this.endpoint, {
             port: 443,
@@ -143,7 +148,7 @@ export class LayoutRecord<T extends RecordFieldsMap, P extends PortalInterface>
         }
         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)
+            let _res = new LayoutRecord<LAYOUT>(this.layout, res.response.recordId, res.response.modId, data.fieldData, data.portalData)
 
             this.emit("duplicated")
             return _res
@@ -171,8 +176,13 @@ export class LayoutRecord<T extends RecordFieldsMap, P extends PortalInterface>
         }
     }
 
-    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 {
-        let obj = super.toObject(filter, portalFilter, portalRowFilter, portalFieldFilter);
+    toObject(
+        filter: (a: FieldBase<FieldValue>) => any = (a) => a.edited,
+        portalFilter: (a: Portal<any>) => any = (a) => a.records.find(record => record.edited),
+        portalRowFilter: (a: PortalRecord<never>) => any = (a) => a.edited,
+        portalFieldFilter: (a: FieldBase<FieldValue>) => any = (a) => a.edited
+    ) {
+        let obj = super.toObject(filter);
 
         // Check if there's been any edited portal information
         let portals = this.portalsArray.filter(a => portalFilter(a))

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,5 +1,5 @@
 /*
- * 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 {