@jd-data-limited/easy-fm 5.0.0-beta.1 → 5.0.0-beta.4

package/dist/records/fields/valueField.d.ts

@@ -0,0 +1,41 @@
+import { BaseField, Parentable, RawValueData } from "./baseField.js";
+import { Temporal } from "temporal-polyfill";
+import { FieldResultTypes } from "../../models/apiResults.js";
+export declare abstract class ValueFieldBase<T, API_FIELD_RESULT extends FieldResultTypes> extends BaseField<T, API_FIELD_RESULT> {
+    #private;
+    /**
+     * @internal
+     * Use `layout.records.create()` instead to create a new LayoutRecord, as this may be safer.
+     * @param record
+     * @param id
+     * @param value
+     * @protected
+     */
+    constructor(record: Parentable, id: string, value: RawValueData);
+    set(content: T): void;
+    /** `true` if this field has changed since it was last loaded or saved. */
+    get edited(): boolean;
+    /**
+     * Resets the 'edited' state of this field, without changing its value
+     */
+    updateOriginalContents(): void;
+    set value(value: T);
+    get value(): T;
+}
+export declare class TextField<T extends string = string> extends ValueFieldBase<T, 'text'> {
+}
+export declare class NumberField<T extends number | null = number | null> extends ValueFieldBase<T, 'number'> {
+}
+export declare class TimeStampField extends ValueFieldBase<Temporal.PlainDateTime | null, 'timeStamp'> {
+    parseRawValue(value: RawValueData): Temporal.PlainDateTime | null;
+    serializeRawValue(): RawValueData;
+}
+export declare class DateField extends ValueFieldBase<Temporal.PlainDate | null, 'date'> {
+    parseRawValue(value: RawValueData): Temporal.PlainDate | null;
+    serializeRawValue(): RawValueData;
+}
+export declare class TimeField extends ValueFieldBase<Temporal.PlainTime | null, 'time'> {
+    parseRawValue(value: RawValueData): Temporal.PlainTime | null;
+    serializeRawValue(): RawValueData;
+}
+export type ValueField = TextField | NumberField | TimeStampField | DateField | TimeField;

package/dist/records/fields/valueField.js

@@ -0,0 +1,108 @@
+import { BaseField } from "./baseField.js";
+import { Temporal } from "temporal-polyfill";
+import { stringToTemporal, temporalToString } from "../../utils/temporal.js";
+export class ValueFieldBase extends BaseField {
+    #originalContents;
+    /**
+     * @internal
+     * Use `layout.records.create()` instead to create a new LayoutRecord, as this may be safer.
+     * @param record
+     * @param id
+     * @param value
+     * @protected
+     */
+    constructor(record, id, value) {
+        super(record, id, value);
+        this.#originalContents = value;
+    }
+    set(content) {
+        /**
+         * Sets the value of the field.
+         *
+         * @param {T | null} content - The new content value to be set. Can be either the type T or null.
+         * @throws {Error} Cannot set container value using set(). Use upload() instead, if the result is a 'container'.
+         */
+        if (this.isCalculationField() || this.isSummaryField()) {
+            throw new Error('Cannot modify the value of an immutable calculation or sumamry field.');
+        }
+        else
+            this._value = content;
+    }
+    /** `true` if this field has changed since it was last loaded or saved. */
+    get edited() {
+        return this.#originalContents !== this.serializeRawValue();
+    }
+    /**
+     * Resets the 'edited' state of this field, without changing its value
+     */
+    updateOriginalContents() {
+        this.#originalContents = this.serializeRawValue();
+    }
+    set value(value) {
+        this.set(value);
+    }
+    get value() {
+        return super.value;
+    }
+}
+export class TextField extends ValueFieldBase {
+}
+export class NumberField extends ValueFieldBase {
+}
+export class TimeStampField extends ValueFieldBase {
+    parseRawValue(value) {
+        if (value === '' || value === null)
+            return null;
+        if (typeof value !== 'string')
+            throw new Error("Received an invalid value for a temporal field.");
+        try {
+            return stringToTemporal(value, 'timestamp', this.parent.layout.database.timeStampFormat);
+        }
+        catch {
+            return Temporal.PlainDateTime.from(value);
+        }
+    }
+    serializeRawValue() {
+        if (this._value === null)
+            return '';
+        return temporalToString(this._value, this.parent.layout.database.timeStampFormat);
+    }
+}
+export class DateField extends ValueFieldBase {
+    parseRawValue(value) {
+        if (value === '' || value === null)
+            return null;
+        if (typeof value !== 'string')
+            throw new Error("Received an invalid value for a temporal field.");
+        try {
+            return stringToTemporal(value, 'date', this.parent.layout.database.dateFormat);
+        }
+        catch {
+            return Temporal.PlainDate.from(value);
+        }
+    }
+    serializeRawValue() {
+        if (this._value === null)
+            return '';
+        return temporalToString(this._value, this.parent.layout.database.dateFormat);
+    }
+}
+export class TimeField extends ValueFieldBase {
+    parseRawValue(value) {
+        if (value === '' || value === null)
+            return null;
+        if (typeof value !== 'string')
+            throw new Error("Received an invalid value for a temporal field.");
+        try {
+            return stringToTemporal(value, 'time', this.parent.layout.database.timeFormat);
+        }
+        catch {
+            return Temporal.PlainTime.from(value);
+        }
+    }
+    serializeRawValue() {
+        if (this._value === null)
+            return '';
+        return temporalToString(this._value, this.parent.layout.database.timeFormat);
+    }
+}

package/dist/records/getOperations/recordGetOperation.js

@@ -2,9 +2,10 @@
  * Copyright (c) 2023-2024. See LICENSE file for more information
  */
 import { LayoutRecord } from '../layoutRecord.js';
-import { ApiRecordResponseObj } from '../../models/apiResults.js';
 import { FMError } from '../../FMError.js';
 import { FindRequestSymbol } from '../../utils/query.js';
+import { Temporal } from "temporal-polyfill";
+import { temporalToString } from "../../utils/temporal.js";
 /** Builder/executor for list and find operations against one layout. */
 export class RecordGetOperation {
     layout;
@@ -131,15 +132,12 @@ export class RecordGetOperation {
                 if (typeof item === 'string')
                     return item;
                 // Re-write date into correct format
-                return item
-                    .moment
-                    .clone()
-                    .utcOffset(this.layout.database.host.timezoneOffsetFunc(item.moment))
-                    .format(item.type === 'date'
-                    ? this.layout.database.host.dateFormat
-                    : item.type === 'time'
-                        ? this.layout.database.host.timeFormat
-                        : this.layout.database.host.timeStampFormat);
+                if (item instanceof Temporal.PlainDateTime)
+                    return temporalToString(item, this.layout.database.timeStampFormat);
+                if (item instanceof Temporal.PlainDate)
+                    return temporalToString(item, this.layout.database.dateFormat);
+                if (item instanceof Temporal.PlainTime)
+                    return temporalToString(item, this.layout.database.timeFormat);
             }).join('');
         }
         return out;
@@ -165,23 +163,25 @@ export class RecordGetOperation {
     }
     async performFind(offset, limit) {
         await this.layout.getLayoutMeta();
-        const isFind = this.isFindRequest;
-        let endpoint = this.layout.endpoint + (isFind ? '/_find' : '/records');
-        if (!isFind)
-            endpoint += '?' + new URLSearchParams(this.generateParamsURL(offset, limit)).toString();
-        const reqData = {
-            // port: 443,
-            method: isFind ? 'POST' : 'GET',
-            type: ApiRecordResponseObj,
-            body: isFind ? JSON.stringify(this.generateParamsBody(offset, limit)) : undefined
-        };
         try {
-            const res = await this.layout.database.fetchJSON(endpoint, reqData);
-            // console.log("RESOLVING")
+            const portals = {};
+            for (const [name, paging] of Object.entries(this.portals))
+                if (paging)
+                    portals[name] = paging;
+            const scripts = {};
+            for (const [name, script] of Object.entries(this.scriptData))
+                if (script)
+                    scripts[name] = { name: script.name, parameter: script.parameter ?? '' };
+            const { value: res, binding } = await this.layout.database.execute({
+                type: 'record.list',
+                layout: this.layout.name,
+                query: this.requests.map(request => ({ fields: request.req, omit: request.omit ?? false })),
+                options: { limit, offset, sort: this.sortData, portals, scripts }
+            });
             if (!this.layout.metadata)
                 await this.layout.getLayoutMeta();
-            return res.data.map(item => {
-                return new LayoutRecord(this.layout, item.recordId, item.modId, item.fieldData, item.portalData);
+            return res.map(item => {
+                return new LayoutRecord(this.layout, item.recordId, item.modId, item.fieldData, item.portalData, [], binding);
             });
         }
         catch (e) {

package/dist/records/layoutRecord.d.ts

@@ -4,14 +4,16 @@ import { PortalRecord } from './portalRecord.js';
 import { Portal } from './portal.js';
 import { type LayoutInterface } from '../layouts/layoutInterface.js';
 import { type LayoutRecordBase } from './layoutRecordBase.js';
-import { type ApiPortalData, type ApiRowDataDef } from '../models/apiResults.js';
+import { type ApiFieldData, ApiFieldMetadata, type ApiPortalData, type ApiRowDataDef } from '../models/apiResults.js';
 import { type LayoutBase } from '../layouts/layoutBase.js';
-import { type Field, type FieldValue } from './field.js';
 import z from 'zod';
+import { Field } from "./fields/field.js";
+import { ContainerField } from './fields/containerField.js';
+import { type SessionBinding } from '../connection/databaseProvider.js';
 export declare class LayoutRecord<LAYOUT extends LayoutInterface> extends RecordBase<LAYOUT['fields']> implements LayoutRecordBase {
     portals: LAYOUT['portals'];
     private readonly portalsToInclude;
-    constructor(layout: LayoutBase, recordId: number | string, modId?: string | number, fieldData?: Record<string, string | number>, portalData?: z.infer<typeof ApiPortalData> | null, portalsToInclude?: Array<keyof LAYOUT['portals']>);
+    constructor(layout: LayoutBase, recordId: number | string, modId?: string | number, fieldData?: z.infer<typeof ApiFieldData>, portalData?: z.infer<typeof ApiPortalData> | null, portalsToInclude?: Array<keyof LAYOUT['portals']>, sessionBinding?: SessionBinding);
     /** Returns all loaded portals on this record as an array. */
     get portalsArray(): Array<Portal<any>>;
     /**
@@ -21,6 +23,7 @@ export declare class LayoutRecord<LAYOUT extends LayoutInterface> extends Record
      * @throws {FMError} - If an error occurs during the commit process.
      */
     commit(extraBody?: extraBodyOptions): Promise<this>;
+    getFieldMetadata(fieldId: string): z.infer<typeof ApiFieldMetadata>;
     protected processPortalData(portalData: z.infer<typeof ApiPortalData>): void;
     /**
      * Reloads this record from FileMaker.
@@ -30,17 +33,21 @@ export declare class LayoutRecord<LAYOUT extends LayoutInterface> extends Record
      * @throws {Error} If commit() has not been called.
      * @throws {FMError} If the retrieval fails.
      */
-    get(): Promise<this>;
+    get(portals?: Record<string, {
+        limit: number;
+        offset: number;
+    }>): Promise<this>;
     /** Creates a duplicate of this record in FileMaker. */
     duplicate(): Promise<LayoutRecord<LAYOUT>>;
     /** Deletes this record from FileMaker. */
     delete(): Promise<void>;
+    refreshContainer(fieldId: string): Promise<ContainerField>;
     /** Returns this record's edited fields as a FileMaker API payload. */
-    fieldsToObject(filter?: (a: Field<FieldValue>) => boolean): Omit<z.infer<typeof ApiRowDataDef>, 'portalData'>;
+    fieldsToObject(filter?: (a: Field) => boolean): Omit<z.infer<typeof ApiRowDataDef>, 'portalData'>;
     /** Returns this record and its portal edits as a FileMaker API payload. */
-    toObject(filter?: (a: Field<FieldValue>) => any, portalFilter?: (a: Portal<any>) => any, portalRowFilter?: (a: PortalRecord<any>) => any, portalFieldFilter?: (a: Field<FieldValue>) => any): {
-        fieldData: Record<string, string | number>;
-        portalData: Record<string, Record<string, string | number>[]>;
+    toObject(filter?: (a: Field) => any, portalFilter?: (a: Portal<any>) => any, portalRowFilter?: (a: PortalRecord<any>) => any, portalFieldFilter?: (a: Field) => any): {
+        fieldData: Record<string, string | number | null>;
+        portalData: Record<string, Record<string, string | number | null>[]>;
         modId: string;
         recordId: string;
         portalDataInfo?: {

package/dist/records/layoutRecord.js

@@ -5,14 +5,13 @@ import { RecordBase } from './recordBase.js';
 import { PortalRecord } from './portalRecord.js';
 import { Portal } from './portal.js';
 import { FMError } from '../FMError.js';
-import { ApiRecordResponseObj } from '../models/apiResults.js';
-import moment from 'moment';
-import z from 'zod';
+import { ValueFieldBase } from "./fields/valueField.js";
+import { ContainerField } from './fields/containerField.js';
 export class LayoutRecord extends RecordBase {
     portals = {};
     portalsToInclude;
-    constructor(layout, recordId, modId = recordId, fieldData = {}, portalData = null, portalsToInclude = []) {
-        super(layout, parseInt(recordId), parseInt(modId), fieldData);
+    constructor(layout, recordId, modId = recordId, fieldData = {}, portalData = null, portalsToInclude = [], sessionBinding) {
+        super(layout, parseInt(recordId), parseInt(modId), fieldData, sessionBinding);
         this.portalsToInclude = portalsToInclude;
         if (portalData) {
             this.processPortalData(portalData);
@@ -32,64 +31,42 @@ export class LayoutRecord extends RecordBase {
         const 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.prerequest.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;
-        }
         if (extraBody.options)
             data.options = extraBody.options;
         if (extraBody.deleteRelatedRecords)
-            data.fieldData.deleteRelated = extraBody.deleteRelatedRecords.map(i => `${i.table}.${i.recordId}`);
+            data.deleteRelatedRecords = extraBody.deleteRelatedRecords;
+        const options = operationOptions(extraBody);
         if (this.recordId === -1) {
             // This is a new LayoutRecord
-            const res = await this.layout.database.fetchJSON(`${this.layout.endpoint}/records`, {
-                method: 'POST',
-                body: JSON.stringify(data),
-                type: z.object({
-                    recordId: z.string(),
-                    modId: z.string(),
-                    scriptError: z.string().optional()
-                })
-            });
-            if (typeof res.scriptError !== 'undefined' && res.scriptError !== '0') {
-                throw new FMError(res.scriptError, res.httpStatus, res);
+            const { value: res, binding } = await this.layout.database.execute({ type: 'record.create', layout: this.layout.name, body: data, options });
+            if (res.scriptError) {
+                throw new FMError(res.scriptError, res.status ?? 200, res);
             }
             this.recordId = parseInt(res.recordId);
             this.modId = parseInt(res.modId);
+            this.sessionBinding = binding;
+            this._onSave();
             return this;
         }
         // for (let item of Object.keys(data)) extraBody[item] = data[item]
-        const res = await this.layout.database.fetchJSON(this.endpoint, {
-            method: 'PATCH',
-            body: JSON.stringify(data),
-            type: z.object({
-                modId: z.string(),
-                newPortalRecordInfo: z.array(z.object({
-                    tableName: z.string(),
-                    recordId: z.string(),
-                    modId: z.string()
-                })).optional(),
-                scriptError: z.string().optional()
-            })
-        });
-        if (typeof res.scriptError !== 'undefined' && res.scriptError !== '0') {
-            throw new FMError(res.scriptError, res.httpStatus, res);
+        const { value: res, binding } = await this.layout.database.execute({ type: 'record.update', layout: this.layout.name, recordId: this.recordId, body: data, options });
+        if (res.scriptError) {
+            throw new FMError(res.scriptError, res.status ?? 200, res);
         }
         this.modId = +res.modId;
+        this.sessionBinding = binding;
         this._onSave();
         return this;
     }
+    getFieldMetadata(fieldId) {
+        if (!this.layout.metadata) {
+            throw new Error("Field metadata not found. Ensure you run layout.getLayoutMeta() first.");
+        }
+        let result = this.layout.metadata.fieldMetaData.find(i => i.name === fieldId);
+        if (!result)
+            throw new Error("Field metadata not found. Ensure you run layout.getLayoutMeta() first.");
+        return result;
+    }
     processPortalData(portalData) {
         for (const portalName of Object.keys(portalData)) {
             const _portal = new Portal(this, portalName);
@@ -97,7 +74,7 @@ export class LayoutRecord extends RecordBase {
                 const fieldData = item;
                 delete fieldData.recordId;
                 delete fieldData.modId;
-                return new PortalRecord(this, _portal, parseInt(item.recordId), parseInt(item.modId), fieldData);
+                return new PortalRecord(this, _portal, parseInt(item.recordId), parseInt(item.modId), fieldData, this.sessionBinding);
             });
             // @ts-expect-error - This code is actually correct, but throws a typescript error
             this.portals[portalName] = _portal;
@@ -111,87 +88,63 @@ export class LayoutRecord extends RecordBase {
      * @throws {Error} If commit() has not been called.
      * @throws {FMError} If the retrieval fails.
      */
-    async get() {
+    async get(portals = {}) {
         if (this.recordId === -1) {
             throw new Error('Cannot get this RecordBase until a commit() is done.');
         }
         if (!this.layout.metadata)
             await this.layout.getLayoutMeta();
-        const res = await this.layout.database.fetchJSON(this.endpoint, {
-            type: ApiRecordResponseObj
-        });
+        const { value: record, binding } = await this.layout.database.execute({ type: 'record.get', layout: this.layout.name, recordId: this.recordId, options: { scripts: {}, portals } });
         // console.log(res, res.response.data)
-        this.modId = +res.data[0].modId;
-        this.processFieldData(res.data[0].fieldData);
+        this.sessionBinding = binding;
+        this.modId = +record.modId;
+        this.processFieldData(record.fieldData);
         this.portalData = [];
-        if (res.data[0].portalData)
-            this.processPortalData(res.data[0].portalData);
+        if (record.portalData)
+            this.processPortalData(record.portalData);
         return this;
     }
     /** Creates a duplicate of this record in FileMaker. */
     async duplicate() {
         const trace = new Error();
-        const res = await this.layout.database.fetchJSON(this.endpoint, {
-            method: 'POST',
-            type: z.object({
-                recordId: z.string(),
-                modId: z.string(),
-                scriptError: z.string().optional()
-            })
-        });
-        if (typeof res.scriptError !== 'undefined' && res.scriptError !== '0') {
-            throw new FMError(res.scriptError, res.httpStatus, res, trace);
+        const { value: res, binding } = await this.layout.database.execute({ type: 'record.duplicate', layout: this.layout.name, recordId: this.recordId, options: emptyOperationOptions() });
+        if (res.scriptError) {
+            throw new FMError(res.scriptError, res.status ?? 200, res, trace);
         }
         const data = this.toObject((a) => true, (a) => true, (a) => false, (a) => false);
-        const _res = new LayoutRecord(this.layout, res.recordId, res.modId, data.fieldData, data.portalData);
+        const _res = new LayoutRecord(this.layout, res.recordId, res.modId, data.fieldData, data.portalData, [], binding);
         this.emit('duplicated');
         return _res;
     }
     /** Deletes this record from FileMaker. */
     async delete() {
-        const res = await this.layout.database.fetchJSON(this.endpoint, {
-            method: 'DELETE',
-            type: z.object({
-                scriptError: z.string().optional()
-            }).optional()
-        });
-        if (typeof res.scriptError !== 'undefined' && res.scriptError !== '0') {
-            throw new FMError(res.scriptError, res.httpStatus, res);
+        const { value: res } = await this.layout.database.execute({ type: 'record.delete', layout: this.layout.name, recordId: this.recordId, options: emptyOperationOptions() });
+        if (res.scriptError) {
+            throw new FMError(res.scriptError, res.status ?? 200, res);
         }
         this.emit('deleted');
     }
+    async refreshContainer(fieldId) {
+        await this.get();
+        const field = this.fields[fieldId];
+        if (!(field instanceof ContainerField))
+            throw new Error(`Container field ${fieldId} was not returned while refreshing record`);
+        return field;
+    }
     /** Returns this record's edited fields as a FileMaker API payload. */
-    fieldsToObject(filter = (a) => a.edited) {
+    fieldsToObject(filter = (a) => a instanceof ValueFieldBase && a.edited) {
         const fieldsProcessed = {};
-        let field;
-        for (field of this.fieldsArray.filter(field => filter(field))) {
-            let value = field.value;
-            if (value instanceof Date) {
-                let _value = moment(value);
-                _value = _value
-                    .utcOffset(this.layout.database.host.timezoneOffsetFunc(_value));
-                switch (field.metadata.result) {
-                    case 'time':
-                        value = _value.format(this.layout.database.host.timeFormat);
-                        break;
-                    case 'date':
-                        value = _value.format(this.layout.database.host.dateFormat);
-                        break;
-                    default:
-                        value = _value.format(this.layout.database.host.timeStampFormat);
-                }
-            }
-            fieldsProcessed[field.id] = value;
+        for (const field of this.fieldsArray.filter(field => filter(field))) {
+            fieldsProcessed[field.id] = field.serializeRawValue();
         }
-        const obj = {
+        return {
             recordId: this.recordId.toString(),
             modId: this.modId.toString(),
             fieldData: fieldsProcessed
         };
-        return obj;
     }
     /** Returns this record and its portal edits as a FileMaker API payload. */
-    toObject(filter = (a) => a.edited, portalFilter = (a) => a.records.find(record => record.edited), portalRowFilter = (a) => a.edited, portalFieldFilter = (a) => a.edited) {
+    toObject(filter = (a) => a instanceof ValueFieldBase && a.edited, portalFilter = (a) => a.records.find(record => record.edited), portalRowFilter = (a) => a.edited, portalFieldFilter = (a) => a instanceof ValueFieldBase && a.edited) {
         const obj = {
             ...this.fieldsToObject(filter),
             portalData: {}
@@ -209,3 +162,13 @@ export class LayoutRecord extends RecordBase {
         return obj;
     }
 }
+function emptyOperationOptions() {
+    return { scripts: {}, portals: {} };
+}
+function operationOptions(extra) {
+    const scripts = {};
+    for (const [name, script] of Object.entries(extra.scripts ?? {}))
+        if (script)
+            scripts[name] = { name: script.name, parameter: script.parameter ?? '' };
+    return { scripts, portals: {} };
+}

package/dist/records/portal.d.ts

@@ -1,7 +1,7 @@
 import { PortalRecord } from './portalRecord.js';
-import { type RecordFieldsMap } from '../layouts/recordFieldsMap.js';
 import { type PortalBase } from './portalBase.js';
 import { type LayoutRecord } from './layoutRecord.js';
+import { RecordFieldsMap } from "../layouts/layoutInterface.js";
 /**
  * Represents a portal.
  *

package/dist/records/portalBase.d.ts

@@ -1,7 +1,6 @@
-import { type RecordFieldsMap } from '../layouts/recordFieldsMap.js';
 import { type RecordBase } from './recordBase.js';
 import { type LayoutRecord } from './layoutRecord.js';
-import { type LayoutInterface } from '../layouts/layoutInterface.js';
+import { type LayoutInterface, RecordFieldsMap } from '../layouts/layoutInterface.js';
 export interface PortalBase<T extends RecordFieldsMap> {
     readonly record: LayoutRecord<LayoutInterface>;
     readonly name: string;

package/dist/records/portalRecord.d.ts

@@ -1,8 +1,12 @@
 import { RecordBase } from './recordBase.js';
 import { type extraBodyOptions, RecordTypes } from '../types.js';
-import { type RecordFieldsMap } from '../layouts/recordFieldsMap.js';
 import { type PortalBase } from './portalBase.js';
-import { type Field, type FieldValue } from './field.js';
+import z from "zod";
+import { ApiFieldMetadata } from "../models/apiResults.js";
+import { RecordFieldsMap } from "../layouts/layoutInterface.js";
+import { Field } from "./fields/field.js";
+import { ContainerField } from './fields/containerField.js';
+import { type SessionBinding } from '../connection/databaseProvider.js';
 /**
  * Represents a PortalRecord, which is a record in a portal within a parent record.
  * @template T - The type of the record's field map.
@@ -10,7 +14,8 @@ import { type Field, type FieldValue } from './field.js';
 export declare class PortalRecord<T extends RecordFieldsMap> extends RecordBase<T> {
     readonly portal: PortalBase<T>;
     readonly type = RecordTypes.PORTAL;
-    constructor(record: RecordBase<any>, portal: PortalBase<any>, recordId: number, modId?: number, fieldData?: {});
+    constructor(record: RecordBase<any>, portal: PortalBase<any>, recordId: number, modId?: number, fieldData?: {}, sessionBinding?: SessionBinding);
+    refreshContainer(fieldId: string): Promise<ContainerField>;
     _onSave(): void;
     /**
      * Commits the parent record, and in turn this one.
@@ -18,8 +23,9 @@ export declare class PortalRecord<T extends RecordFieldsMap> extends RecordBase<
      * @param {extraBodyOptions} [extraBody={}] - The optional extra body options.
      * @returns {Promise} - A promise that resolves when the record is committed.
      */
-    commit(extraBody?: extraBodyOptions): Promise<import("./layoutRecord.js").LayoutRecord<import("../index.js").LayoutInterface>>;
-    toObject(fieldFilter: (a: Field<FieldValue>) => boolean): {
+    commit(extraBody?: extraBodyOptions): Promise<import("./layoutRecord.js").LayoutRecord<import("../layouts/layoutInterface.js").LayoutInterface>>;
+    getFieldMetadata(fieldId: string): z.infer<typeof ApiFieldMetadata>;
+    toObject(fieldFilter: (a: Field) => boolean): {
         modId?: string;
         recordId?: string;
     } & Record<string, string>;

package/dist/records/portalRecord.js

@@ -3,6 +3,7 @@
  */
 import { RecordBase } from './recordBase.js';
 import { RecordTypes } from '../types.js';
+import { ContainerField } from './fields/containerField.js';
 /**
  * Represents a PortalRecord, which is a record in a portal within a parent record.
  * @template T - The type of the record's field map.
@@ -10,10 +11,19 @@ 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, fieldData);
+    constructor(record, portal, recordId, modId = recordId, fieldData = {}, sessionBinding) {
+        super(record.layout, recordId, modId, fieldData, sessionBinding);
         this.portal = portal;
     }
+    async refreshContainer(fieldId) {
+        await this.portal.record.get({ [this.portal.name]: { offset: 1, limit: Math.max(1, this.portal.records.length) } });
+        const portal = this.portal.record.portalsArray.find(item => item.name === this.portal.name);
+        const record = portal?.records.find(item => item.recordId === this.recordId);
+        const field = record?.fields[fieldId];
+        if (!(field instanceof ContainerField))
+            throw new Error(`Container field ${fieldId} was not returned while refreshing record`);
+        return field;
+    }
     _onSave() {
         super._onSave();
         this.portal.record._onSave();
@@ -27,6 +37,18 @@ export class PortalRecord extends RecordBase {
     async commit(extraBody = {}) {
         return await this.portal.record.commit(extraBody);
     }
+    getFieldMetadata(fieldId) {
+        if (!this.layout.metadata) {
+            throw new Error("Field metadata not found. Ensure you run layout.getLayoutMeta() first.");
+        }
+        const portalMetadata = this.portal
+            ? this.layout.metadata.portalMetaData[this.portal.name] ?? []
+            : Object.values(this.layout.metadata.portalMetaData).flat();
+        const result = portalMetadata.find(i => i.name === fieldId);
+        if (!result)
+            throw new Error("Field metadata not found. Ensure you run layout.getLayoutMeta() first.");
+        return result;
+    }
     toObject(fieldFilter) {
         const res = {
             recordId: this.recordId === -1 ? undefined : this.recordId.toString(),