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

package/dist/records/field.js

@@ -1,145 +1,75 @@
 /*
  * Copyright (c) 2023-2024. See LICENSE file for more information
  */
-var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
-    var useValue = arguments.length > 2;
-    for (var i = 0; i < initializers.length; i++) {
-        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
-    }
-    return useValue ? value : void 0;
-};
-var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
-    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
-    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
-    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
-    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
-    var _, done = false;
-    for (var i = decorators.length - 1; i >= 0; i--) {
-        var context = {};
-        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
-        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
-        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
-        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
-        if (kind === "accessor") {
-            if (result === void 0) continue;
-            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
-            if (_ = accept(result.get)) descriptor.get = _;
-            if (_ = accept(result.set)) descriptor.set = _;
-            if (_ = accept(result.init)) initializers.unshift(_);
-        }
-        else if (_ = accept(result)) {
-            if (kind === "field") initializers.unshift(_);
-            else descriptor[key] = _;
-        }
-    }
-    if (target) Object.defineProperty(target, contextIn.name, descriptor);
-    done = true;
-};
-var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
-    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
-    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
-};
 import { RecordTypes } from '../types.js';
-import { ApiFieldDisplayTypes, ApiFieldResultTypes, ApiFieldTypes } from '../models/apiResults.js';
+import { ApiFieldDisplayTypes, ApiFieldResultTypes, ApiFieldTypes, ApiResults } from '../models/apiResults.js';
 import { FMError } from '../FMError.js';
+import { Readable } from 'node:stream';
+import { HttpError } from '../connection/Session.js';
 /**
  * A class representing a field in a record.
  *
  * @template T - The type of the field value.
  */
-let Field = (() => {
-    let _instanceExtraInitializers = [];
-    let _private_streamAsync_decorators;
-    let _private_streamAsync_descriptor;
-    let _arrayBuffer_decorators;
-    return class Field {
-        static {
-            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
-            _private_streamAsync_decorators = [containerDownloadFunction];
-            _arrayBuffer_decorators = [containerDownloadFunction];
-            __esDecorate(this, _private_streamAsync_descriptor = { value: __setFunctionName(async function () {
-                    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 { data: req.body, mime: req.headers.get('Content-Type') ?? '' };
-                }, "#streamAsync") }, _private_streamAsync_decorators, { kind: "method", name: "#streamAsync", static: false, private: true, access: { has: obj => #streamAsync in obj, get: obj => obj.#streamAsync }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(this, null, _arrayBuffer_decorators, { kind: "method", name: "arrayBuffer", static: false, private: false, access: { has: obj => "arrayBuffer" in obj, get: obj => obj.arrayBuffer }, metadata: _metadata }, null, _instanceExtraInitializers);
-            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-        }
-        parent = __runInitializers(this, _instanceExtraInitializers);
-        id;
-        _value;
-        #originalContents;
-        static firstContainerDownload = null;
-        constructor(record, id, originalContents) {
-            this.parent = record;
-            this.id = id;
-            this._value = originalContents;
-            this.#originalContents = originalContents;
-        }
-        get edited() {
-            return this.#originalContents !== this._value;
-        }
-        /**
-         * Resets the 'edited' state of this field, without changing its value
-         */
-        updateOriginalContents() {
-            this.#originalContents = this._value;
-        }
-        /**
-         * 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'.
-         */
-        set(content) {
-            if (this.metadata.result === 'container')
-                throw new Error('Cannot set container value using set(). Use upload() instead.');
-            else
-                this._value = content;
-        }
-        get metadata() {
-            if (!this.parent.layout.metadata) {
-                // Default to a regular text field
-                return {
-                    name: this.id.toString(),
-                    type: ApiFieldTypes.NORMAL,
-                    displayType: ApiFieldDisplayTypes.EDIT_TEXT,
-                    result: ApiFieldResultTypes.TEXT,
-                    global: false,
-                    autoEnter: true,
-                    fourDigitYear: false,
-                    maxRepeat: 1,
-                    maxCharacters: 0,
-                    notEmpty: false,
-                    numeric: false,
-                    timeOfDay: false,
-                    repetitions: 1,
-                    valueList: ''
-                };
-            }
-            if (this.parent.type === RecordTypes.PORTAL && this.parent.portal) {
-                return this.parent.layout.metadata.portalMetaData[this.parent.portal.name || 'portal not attached'].find(i => i.name === this.id) ??
-                    {
-                        name: this.id.toString(),
-                        type: ApiFieldTypes.NORMAL,
-                        displayType: ApiFieldDisplayTypes.EDIT_TEXT,
-                        result: ApiFieldResultTypes.TEXT,
-                        global: false,
-                        autoEnter: true,
-                        fourDigitYear: false,
-                        maxRepeat: 1,
-                        maxCharacters: 0,
-                        notEmpty: false,
-                        numeric: false,
-                        timeOfDay: false,
-                        repetitions: 1,
-                        valueList: ''
-                    };
-            }
-            else {
-                return this.parent.layout.metadata.fieldMetaData.find(i => i.name === this.id) ?? {
+export class Field {
+    parent;
+    id;
+    _value;
+    #originalContents;
+    static firstContainerDownload = null;
+    constructor(record, id, originalContents) {
+        this.parent = record;
+        this.id = id;
+        this._value = originalContents;
+        this.#originalContents = originalContents;
+    }
+    /** `true` if this field has changed since it was last loaded or saved. */
+    get edited() {
+        return this.#originalContents !== this._value;
+    }
+    /**
+     * Resets the 'edited' state of this field, without changing its value
+     */
+    updateOriginalContents() {
+        this.#originalContents = this._value;
+    }
+    /**
+     * 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'.
+     */
+    set(content) {
+        if (this.metadata.result === 'container')
+            throw new Error('Cannot set container value using set(). Use upload() instead.');
+        else
+            this._value = content;
+    }
+    /** Returns the FileMaker metadata for this field. */
+    get metadata() {
+        if (!this.parent.layout.metadata) {
+            // Default to a regular text field
+            return {
+                name: this.id.toString(),
+                type: ApiFieldTypes.NORMAL,
+                displayType: ApiFieldDisplayTypes.EDIT_TEXT,
+                result: ApiFieldResultTypes.TEXT,
+                global: false,
+                autoEnter: true,
+                fourDigitYear: false,
+                maxRepeat: 1,
+                maxCharacters: 0,
+                notEmpty: false,
+                numeric: false,
+                timeOfDay: false,
+                repetitionStart: 1,
+                repetitionEnd: 1,
+                valueList: ''
+            };
+        }
+        if (this.parent.type === RecordTypes.PORTAL && this.parent.portal) {
+            return this.parent.layout.metadata.portalMetaData[this.parent.portal.name || 'portal not attached'].find(i => i.name === this.id) ??
+                {
                     name: this.id.toString(),
                     type: ApiFieldTypes.NORMAL,
                     displayType: ApiFieldDisplayTypes.EDIT_TEXT,
@@ -152,117 +82,111 @@ let Field = (() => {
                     notEmpty: false,
                     numeric: false,
                     timeOfDay: false,
-                    repetitions: 1,
+                    repetitionStart: 1,
+                    repetitionEnd: 1,
                     valueList: ''
                 };
-            }
-        }
-        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;
-        }
-        set value(value) {
-            this.set(value);
-        }
-        get string() {
-            if (typeof this._value === 'string') {
-                return this._value;
-            }
-            throw new Error('Field value is not a string');
-        }
-        /**
-         * 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._apiRequestRaw(`${this.parent.endpoint}/containers/${this.id}/1`, {
-                method: 'POST',
-                headers: {
-                // Authorization: 'Bearer ' + this.parent.layout.database.token,
-                // 'Content-Type': 'multipart/form-data'
-                },
-                body: form
-            });
-            if (!res.ok) {
-                throw new Error(`Upload failed with HTTP error: ${res.status} (${res.statusText})`);
-            }
-            const data = await res.json();
-            if (data.messages[0].code === '0')
-                return;
-            else {
-                throw new FMError(data.messages[0].code, res.status, res);
-            }
         }
-        get #streamAsync() { return _private_streamAsync_descriptor.value; }
-        async stream() {
-            return await this.#streamAsync();
+        else {
+            return this.parent.layout.metadata.fieldMetaData.find(i => i.name === this.id) ?? {
+                name: this.id.toString(),
+                type: ApiFieldTypes.NORMAL,
+                displayType: ApiFieldDisplayTypes.EDIT_TEXT,
+                result: ApiFieldResultTypes.TEXT,
+                global: false,
+                autoEnter: true,
+                fourDigitYear: false,
+                maxRepeat: 1,
+                maxCharacters: 0,
+                notEmpty: false,
+                numeric: false,
+                timeOfDay: false,
+                repetitionStart: 1,
+                repetitionEnd: 1,
+                valueList: ''
+            };
         }
-        async arrayBuffer() {
-            const req = await this.parent.layout.database._apiRequestRaw(this.string, { useCookieJar: true });
-            if (!req.ok)
-                throw new Error(`HTTP Error: ${req.status} (${req.statusText})`);
-            return { data: await req.arrayBuffer(), mime: req.headers.get('Content-Type') ?? '' };
-        }
-    };
-})();
-export { Field };
-function containerDownloadFunction(originalMethod, context) {
-    async function replacementMethod(...args) {
-        return await ContainerDownloadExecutor.processTask(async () => await originalMethod.call(this, ...args));
     }
-    return replacementMethod;
-}
-class ContainerDownloadExecutorClass {
-    hasDownloadedFirstContainer = 0;
-    waitingFuncs = [];
-    async processTask(task) {
-        const isFirstTask = this.hasDownloadedFirstContainer === 0;
-        if (isFirstTask) {
-            this.hasDownloadedFirstContainer = 1;
-            let res;
-            try {
-                res = await task();
-            }
-            catch (e) {
-                this.hasDownloadedFirstContainer = 0;
-                const nextTask = this.waitingFuncs.splice(0, 1)[0];
-                if (nextTask) {
-                    this.processTask(nextTask.func)
-                        .then(res => nextTask.done(res))
-                        .catch(e => nextTask.err(e));
-                }
-                throw e;
-            }
-            this.hasDownloadedFirstContainer = 2;
-            for (const task of this.waitingFuncs) {
-                task.func()
-                    .then((res) => task.done(res))
-                    .catch((e) => task.err(e));
-            }
-            return res;
+    /** 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;
+    }
+    set value(value) {
+        this.set(value);
+    }
+    /** Returns this field value as a string. Throws if the value is not a string. */
+    get string() {
+        if (typeof this._value === 'string') {
+            return this._value;
         }
-        else if (this.hasDownloadedFirstContainer === 1) {
-            return await new Promise((resolve, reject) => {
-                this.waitingFuncs.push({
-                    func: task,
-                    done: resolve,
-                    err: reject
-                });
-            });
+        throw new Error('Field value is not a string');
+    }
+    /**
+     * 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);
         }
-        else
-            return await task();
+    }
+    async #streamAsync(options = {}) {
+        const req = await this.parent.layout.database.fetch(this.string, {
+            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') ?? '' };
     }
 }
-const ContainerDownloadExecutor = new ContainerDownloadExecutorClass();

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 {};