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

package/README.md

@@ -23,7 +23,7 @@ npm install @jd-data-limited/easy-fm
 ## Quick Start
 
 ```ts
-import FMHost from "@jd-data-limited/easy-fm"
+import {FMHost} from "@jd-data-limited/easy-fm"
 
 const host = new FMHost("https://example.com")
 
@@ -57,6 +57,8 @@ for (const record of records) {
 
 ## Documentation
 
+> Updating from v4 to v5? Check the guide here; [`docs/upgrade-to-v5.md`](./docs/upgrade-to-v5.md)
+
 Start here:
 
 - [`docs/getting-started.md`](./docs/getting-started.md): first connection, first find, closing sessions
@@ -67,7 +69,6 @@ Task guides:
 - [`docs/working-with-records.md`](./docs/working-with-records.md): list, create, update, duplicate, delete, portal rows
 - [`docs/query-recipes.md`](./docs/query-recipes.md): find requests, sorting, paging, script hooks
 - [`docs/authentication-and-sessions.md`](./docs/authentication-and-sessions.md): auth modes, pooling, lifecycle
-- [`docs/timezones.md`](./docs/timezones.md): date, time, and timestamp behavior
 - [`docs/typescript-layouts.md`](./docs/typescript-layouts.md): typed layouts and stronger autocomplete
 - [`docs/testGuide.md`](./docs/testGuide.md): local test commands
 

package/dist/bin/generateTypes.js

@@ -78,7 +78,7 @@ export async function generateTypesCLI() {
             default: true,
             message: "Verify your server's identity",
             when(previousAnswers) {
-                return previousAnswers.hostname.startsWith('https://');
+                return previousAnswers.hostname?.startsWith('https://');
             }
         },
         {
@@ -98,7 +98,7 @@ export async function generateTypesCLI() {
             mask: '*'
         }
     ]);
-    const HOST = new FMHost(data.hostname, () => data.timezoneOffset, data.verify);
+    const HOST = new FMHost(data.hostname, data.verify);
     const DATABASE = HOST.database({
         database: data.database,
         credentials: {

package/dist/bin/stressSearch.js

@@ -175,7 +175,7 @@ async function main() {
         warmup,
         concurrencyLevels
     });
-    const fmHost = new FMHost(host, (moment) => 0 - moment.toDate().getTimezoneOffset(), false);
+    const fmHost = new FMHost(host, false);
     const rows = [];
     const connection = fmHost.database({
         database,

package/dist/connection/FMHost.d.ts

@@ -2,7 +2,6 @@ import { type Database } from './database.js';
 import { type HostBase } from './HostBase.js';
 import { type databaseOptionsWithExternalSources, FMHostMetadata, type loginOptionsClaris, type loginOptionsFileMaker, type loginOptionsOAuth } from '../types.js';
 import { type DatabaseStructure } from '../databaseStructure.js';
-import { type Moment } from 'moment';
 import z from 'zod';
 import { type DatabaseProtocol } from './Session.js';
 /**
@@ -10,11 +9,10 @@ import { type DatabaseProtocol } from './Session.js';
  */
 export default class FMHost implements HostBase {
     readonly hostname: string;
-    readonly timezoneOffsetFunc: (moment: Moment) => number;
     readonly verify: boolean;
     readonly protocol: DatabaseProtocol;
     _metadata: z.infer<typeof FMHostMetadata> | null;
-    constructor(_hostname: string, timezoneOffset?: (moment: Moment) => number, verify?: boolean);
+    constructor(_hostname: string, verify?: boolean);
     get metadata(): z.infer<typeof FMHostMetadata>;
     /** FileMaker host date format converted to Moment-compatible tokens. */
     get dateFormat(): string;

package/dist/connection/FMHost.js

@@ -13,17 +13,15 @@ import { DatabaseConstantSession } from './databaseConstantSession.js';
  */
 export default class FMHost {
     hostname;
-    timezoneOffsetFunc;
     verify;
     protocol;
     _metadata = null;
-    constructor(_hostname, timezoneOffset = (moment) => 0 - (new Date()).getTimezoneOffset(), verify = true) {
+    constructor(_hostname, verify = true) {
         if (!(/^https?:\/\//).test(_hostname))
             throw new Error('hostname MUST begin with either http:// or https://');
         const url = new URL(_hostname);
         this.protocol = url.protocol;
         this.hostname = url.hostname;
-        this.timezoneOffsetFunc = timezoneOffset;
         this.verify = verify;
     }
     get metadata() {

package/dist/connection/HostBase.d.ts

@@ -1,11 +1,9 @@
 import { type FMHostMetadata } from '../types.js';
-import { type Moment } from 'moment';
 import { type z } from 'zod';
 import { type DatabaseProtocol } from './Session.js';
 export interface HostBase {
     readonly hostname: string;
     readonly protocol: DatabaseProtocol;
-    readonly timezoneOffsetFunc: (moment: Moment) => number;
     readonly verify: boolean;
     metadata: z.infer<typeof FMHostMetadata>;
     getMetadata: () => PromiseLike<any>;

package/dist/index.d.ts

@@ -13,7 +13,7 @@ export { RecordBase } from './records/recordBase.js';
 /** Record returned from a layout. Supports fetch, commit, duplicate, and delete. */
 export { LayoutRecord } from './records/layoutRecord.js';
 /** Type helpers for describing typed layouts and portals. */
-export { type LayoutInterface, type PortalInterface } from './layouts/layoutInterface.js';
+export { type LayoutInterface, type PortalInterface, type RecordFieldsMap } from './layouts/layoutInterface.js';
 /** Record returned from a portal row. */
 export { PortalRecord } from './records/portalRecord.js';
 /** Wrapper around portal rows included in a layout record. */
@@ -22,12 +22,15 @@ export { Portal } from './records/portal.js';
 export { type FindRequest, type FindRequestRaw, RecordGetOperation } from './records/getOperations/recordGetOperation.js';
 /** Entry point for `layout.records.*` operations. */
 export { LayoutRecordManager } from './layouts/layoutRecordManager.js';
-/** Type alias for map of fields on a typed record. */
-export { type RecordFieldsMap } from './layouts/recordFieldsMap.js';
 /** Helpers for safe FileMaker find query construction and date/time formatting. */
 export { asDate, asTime, asTimestamp, query, queryEscape } from './utils/query.js';
+/** Conversion helpers for FileMaker-formatted Temporal values. */
+export * from './records/fields/valueField.js';
+export * from './records/fields/containerField.js';
+export { type Field } from './records/fields/field.js';
+export { stringToTemporal, temporalToString, type TemporalValue, type TemporalValueType } from './utils/temporal.js';
 /** Field wrapper used for reading, editing, and container access. */
-export { type Container, Field } from './records/field.js';
+export { type BaseField } from './records/fields/baseField.js';
 /** Default export. Represents FileMaker host/server. */
 export default FMHost;
 export { 

package/dist/index.js

@@ -22,7 +22,9 @@ export { RecordGetOperation } from './records/getOperations/recordGetOperation.j
 export { LayoutRecordManager } from './layouts/layoutRecordManager.js';
 /** Helpers for safe FileMaker find query construction and date/time formatting. */
 export { asDate, asTime, asTimestamp, query, queryEscape } from './utils/query.js';
-/** Field wrapper used for reading, editing, and container access. */
-export { Field } from './records/field.js';
+/** Conversion helpers for FileMaker-formatted Temporal values. */
+export * from './records/fields/valueField.js';
+export * from './records/fields/containerField.js';
+export { stringToTemporal, temporalToString } from './utils/temporal.js';
 /** Default export. Represents FileMaker host/server. */
 export default FMHost;

package/dist/layouts/layoutInterface.d.ts

@@ -1,7 +1,8 @@
 import { type Portal } from '../records/portal.js';
-import { type RecordFieldsMap } from './recordFieldsMap.js';
+import { type Field } from '../records/fields/field.js';
 export interface LayoutInterface {
     fields: RecordFieldsMap;
     portals: PortalInterface;
 }
+export type RecordFieldsMap = Record<string, Field>;
 export type PortalInterface = Record<string | number | symbol, Portal<RecordFieldsMap>>;

package/dist/models/apiResults.d.ts

@@ -21,6 +21,7 @@ export declare const ApiFieldResultTypes: {
     readonly TIMESTAMP: "timeStamp";
     readonly CONTAINER: "container";
 };
+export type FieldResultTypes = z.infer<typeof ApiFieldResultTypes>;
 export declare const ApiMessage: z.ZodObject<{
     code: z.ZodCoercedNumber<unknown>;
     message: z.ZodString;
@@ -166,7 +167,7 @@ export declare const ApiScriptResult: z.ZodObject<{
     scriptError: z.ZodString;
     scriptResult: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-export declare const ApiFieldData: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+export declare const ApiFieldData: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>>;
 export declare const ApiResultSetObj: z.ZodObject<{
     database: z.ZodString;
     layout: z.ZodString;
@@ -175,10 +176,10 @@ export declare const ApiResultSetObj: z.ZodObject<{
     foundCount: z.ZodNumber;
     returnedCount: z.ZodNumber;
 }, z.core.$strip>;
-export declare const ApiPortalData: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>>;
+export declare const ApiPortalData: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>>>>;
 export declare const ApiRowDataDef: z.ZodObject<{
-    fieldData: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-    portalData: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>>;
+    fieldData: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>>;
+    portalData: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>>>>;
     modId: z.ZodString;
     recordId: z.ZodString;
     portalDataInfo: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -190,8 +191,8 @@ export declare const ApiRowDataDef: z.ZodObject<{
 }, z.core.$strip>;
 export declare const ApiRecordResponseObj: z.ZodObject<{
     data: z.ZodArray<z.ZodObject<{
-        fieldData: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-        portalData: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>>;
+        fieldData: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>>;
+        portalData: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>>>>;
         modId: z.ZodString;
         recordId: z.ZodString;
         portalDataInfo: z.ZodOptional<z.ZodArray<z.ZodObject<{

package/dist/models/apiResults.js

@@ -70,7 +70,7 @@ export const ApiScriptResult = z.object({
     scriptError: z.string(),
     scriptResult: z.string().optional()
 });
-export const ApiFieldData = z.record(z.string(), z.union([z.string(), z.number()]));
+export const ApiFieldData = z.record(z.string(), z.union([z.string(), z.number(), z.null()]));
 export const ApiResultSetObj = z.object({
     database: z.string(),
     layout: z.string(),

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

@@ -0,0 +1,57 @@
+import { RecordTypes } from '../../types.js';
+import { type ApiFieldMetadata, FieldResultTypes } from '../../models/apiResults.js';
+import { type LayoutBase } from '../../layouts/layoutBase.js';
+import { type z } from 'zod';
+export type ContainerValue = null;
+/**
+ * RawValueData refers to the raw shapes of data we receive from or sent to FileMaker.
+ */
+export type RawValueData = string | number | null;
+export interface Parentable {
+    layout: LayoutBase;
+    type: RecordTypes;
+    endpoint: string;
+    portal?: {
+        name: string;
+    };
+    getFieldMetadata(fieldId: string): z.infer<typeof ApiFieldMetadata>;
+}
+/**
+ * A class representing a field in a record.
+ * API_FIELD_RESULT defines the value of field.metadata.result for the abstracted field type
+ *
+ * @template T - The type of the field value.
+ */
+export declare abstract class BaseField<T extends unknown, API_FIELD_RESULT extends FieldResultTypes> {
+    parent: Parentable;
+    id: string;
+    protected _value: T;
+    /**
+     * @internal
+     * Use `layout.records.create()` instead to create a new LayoutRecord, as this may be safer.
+     * @param record
+     * @param id
+     * @param value
+     * @protected
+     */
+    protected constructor(record: Parentable, id: string, value: RawValueData);
+    /**
+     * Takes in data in the format that FileMaker gives us and converts it to a more JavaScript-friendly format.
+     * This method is intended to be overriden.
+     * @param value
+     */
+    parseRawValue(value: RawValueData): T;
+    /**
+     * Converts data back into a format that can be sent to FileMaker. Intended to be overriden if conversion is non-standard.
+     */
+    serializeRawValue(): RawValueData;
+    updateFromRawValue(value: RawValueData): void;
+    /** Returns the FileMaker metadata for this field. */
+    get metadata(): z.infer<typeof ApiFieldMetadata> & {
+        result: API_FIELD_RESULT;
+    };
+    /** Gets or sets the current field value. */
+    get value(): T;
+    isCalculationField(): boolean;
+    isSummaryField(): boolean;
+}

package/dist/records/fields/baseField.js

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2023-2024. See LICENSE file for more information
+ */
+/**
+ * A class representing a field in a record.
+ * API_FIELD_RESULT defines the value of field.metadata.result for the abstracted field type
+ *
+ * @template T - The type of the field value.
+ */
+export class BaseField {
+    parent;
+    id;
+    _value;
+    /**
+     * @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) {
+        this.parent = record;
+        this.id = id;
+        this._value = this.parseRawValue(value);
+    }
+    /**
+     * Takes in data in the format that FileMaker gives us and converts it to a more JavaScript-friendly format.
+     * This method is intended to be overriden.
+     * @param value
+     */
+    parseRawValue(value) {
+        return value;
+    }
+    /**
+     * Converts data back into a format that can be sent to FileMaker. Intended to be overriden if conversion is non-standard.
+     */
+    serializeRawValue() {
+        return this._value;
+    }
+    updateFromRawValue(value) {
+        this._value = this.parseRawValue(value);
+    }
+    /** Returns the FileMaker metadata for this field. */
+    get metadata() {
+        return this.parent.getFieldMetadata(this.id);
+    }
+    /** Gets or sets the current field value. */
+    get value() {
+        // 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;
+    }
+    isCalculationField() {
+        return this.metadata.type === 'calculation';
+    }
+    isSummaryField() {
+        return this.metadata.type === 'summary';
+    }
+}

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

@@ -0,0 +1,35 @@
+import { BaseField, Parentable, RawValueData } from "./baseField.js";
+import { Readable } from 'node:stream';
+interface StreamOptions {
+    abortSignal?: AbortSignal;
+}
+export declare class ContainerField extends BaseField<string, 'container'> {
+    #private;
+    static firstContainerDownload: Promise<any> | null;
+    constructor(record: Parentable, id: string, value: RawValueData);
+    /**
+     * Uploads a file to the container field.
+     *
+     * @param {Buffer} file - The file content as a buffer.
+     *
+     * @throws {Error} - Cannot upload a file to the field if it's not a container field.
+     * @throws {Error} - Upload failed with HTTP error.
+     *
+     * @returns {Promise<void>} - A promise that resolves when the file is successfully uploaded.
+     */
+    upload(file: File): Promise<void>;
+    stream(): Promise<{
+        data: Readable;
+        mime: string;
+    }>;
+    /**
+     * Returns the container download as a Web `Response`.
+     */
+    webStream(options: StreamOptions): Promise<Response>;
+    /** Downloads the full container contents into memory. */
+    arrayBuffer(): Promise<{
+        data: ArrayBuffer;
+        mime: string;
+    }>;
+}
+export {};

package/dist/records/fields/containerField.js

@@ -0,0 +1,78 @@
+import { BaseField } from "./baseField.js";
+import { FMError } from '../../FMError.js';
+import { Readable } from 'node:stream';
+import { HttpError } from '../../connection/Session.js';
+import { ApiResults } from "../../models/apiResults.js";
+export class ContainerField extends BaseField {
+    static firstContainerDownload = null;
+    constructor(record, id, value) {
+        super(record, id, value);
+    }
+    /**
+     * Uploads a file to the container field.
+     *
+     * @param {Buffer} file - The file content as a buffer.
+     *
+     * @throws {Error} - Cannot upload a file to the field if it's not a container field.
+     * @throws {Error} - Upload failed with HTTP error.
+     *
+     * @returns {Promise<void>} - A promise that resolves when the file is successfully uploaded.
+     */
+    async upload(file) {
+        if (this.metadata.result !== 'container') {
+            throw new Error('Cannot upload a file to the field; ' + this.id + ' (not a container field)');
+        }
+        const form = new FormData();
+        form.append('upload', file);
+        const res = await this.parent.layout.database.fetch(`${this.parent.endpoint}/containers/${this.id}/1`, {
+            method: 'POST',
+            body: form
+        });
+        if (!res.ok) {
+            throw await HttpError.new(res);
+        }
+        const data = ApiResults.parse(await res.json());
+        if (data.messages[0].code === 0)
+            return;
+        else {
+            throw new FMError(data.messages[0].code, res.status, res);
+        }
+    }
+    async #streamAsync(options = {}) {
+        const req = await this.parent.layout.database.fetch(this.value, {
+            signal: options.abortSignal ?? null
+        });
+        // const req = await this.parent.layout.database._apiRequestRaw(this.string, {useCookieJar: true})
+        if (!req.ok || !req.body) {
+            throw new Error(`HTTP Error: ${req.status} (${req.statusText})`);
+        }
+        return req;
+    }
+    /**
+     * @deprecated use webStream instead.
+     */
+    async stream() {
+        const stream = await this.#streamAsync();
+        if (!stream.body) {
+            throw await HttpError.new(stream);
+        }
+        return {
+            // @ts-expect-error stream types are correct
+            data: Readable.fromWeb(stream.body),
+            mime: stream.headers.get('Content-Type') ?? ''
+        };
+    }
+    /**
+     * Returns the container download as a Web `Response`.
+     */
+    async webStream(options) {
+        return await this.#streamAsync(options);
+    }
+    /** Downloads the full container contents into memory. */
+    async arrayBuffer() {
+        const stream = await this.#streamAsync();
+        if (!stream.ok)
+            throw await HttpError.new(stream);
+        return { data: await stream.arrayBuffer(), mime: stream.headers.get('Content-Type') ?? '' };
+    }
+}

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

@@ -0,0 +1,3 @@
+import { ValueField } from "./valueField.js";
+import { ContainerField } from "./containerField.js";
+export type Field = ValueField | ContainerField;

package/dist/records/fields/field.js

@@ -0,0 +1 @@
+export {};

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.host.timeStampFormat);
+        }
+        catch {
+            return Temporal.PlainDateTime.from(value);
+        }
+    }
+    serializeRawValue() {
+        if (this._value === null)
+            return '';
+        return temporalToString(this._value, this.parent.layout.database.host.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.host.dateFormat);
+        }
+        catch {
+            return Temporal.PlainDate.from(value);
+        }
+    }
+    serializeRawValue() {
+        if (this._value === null)
+            return '';
+        return temporalToString(this._value, this.parent.layout.database.host.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.host.timeFormat);
+        }
+        catch {
+            return Temporal.PlainTime.from(value);
+        }
+    }
+    serializeRawValue() {
+        if (this._value === null)
+            return '';
+        return temporalToString(this._value, this.parent.layout.database.host.timeFormat);
+    }
+}

package/dist/records/getOperations/recordGetOperation.js

@@ -5,6 +5,8 @@ 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 +133,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.host.timeStampFormat);
+                if (item instanceof Temporal.PlainDate)
+                    return temporalToString(item, this.layout.database.host.dateFormat);
+                if (item instanceof Temporal.PlainTime)
+                    return temporalToString(item, this.layout.database.host.timeFormat);
             }).join('');
         }
         return out;