@jd-data-limited/easy-fm 4.0.16 → 4.1.1

package/src/records/field.js

@@ -1,149 +1,266 @@
 /*
  * Copyright (c) 2023-2024. See LICENSE file for more information
  */
-import { DownloadModes, RecordTypes } from "../types.js";
-import { ApiFieldDisplayTypes, ApiFieldResultTypes, ApiFieldTypes } from "../models/apiResults.js";
-export class Field {
-    parent;
-    id;
-    _value;
-    edited;
-    constructor(record, id, contents) {
-        this.parent = record;
-        this.id = id;
-        this._value = contents;
-        this.edited = false;
+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);
     }
-    set(content) {
-        if (this.metadata.result === "container")
-            throw "Cannot set container value using set(). Use upload() instead.";
-        // @ts-ignore
-        if (!content)
-            this._value = "";
-        // @ts-ignore
-        else
-            this._value = content;
-        this.edited = true;
+    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] = _;
+        }
     }
-    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 (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 { FMError } from "../FMError.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 () {
+                    let 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.body;
+                }, "#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 });
         }
-        if (this.parent.type === RecordTypes.PORTAL) {
-            // @ts-ignore
-            return this.parent.layout.metadata.portalMetaData[this.parent.portal.name || "portal not attached"].find(i => i.name === this.id) || {
-                name: this.id.toString(),
-                type: 'normal',
-                displayType: 'editText',
-                result: 'text',
-                global: false,
-                autoEnter: true,
-                fourDigitYear: false,
-                maxRepeat: 1,
-                maxCharacters: 0,
-                notEmpty: false,
-                numeric: false,
-                timeOfDay: false,
-                repetitionStart: 1,
-                repetitionEnd: 1
-            };
+        parent = __runInitializers(this, _instanceExtraInitializers);
+        id;
+        _value;
+        edited;
+        static firstContainerDownload = null;
+        constructor(record, id, contents) {
+            this.parent = record;
+            this.id = id;
+            this._value = contents;
+            this.edited = false;
         }
-        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,
-                repetitions: 1,
-                valueList: ""
-            };
+        /**
+         * 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;
+            this.edited = true;
         }
-    }
-    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._value = value;
-    }
-    get string() {
-        if (typeof this._value === "string") {
-            return this._value;
+        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) ?? {
+                    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: ''
+                };
+            }
         }
-        throw "Field value is not a string";
-    }
-    get date() {
-        if (this._value instanceof Date) {
+        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;
         }
-        throw "Field value is not a date";
-    }
-    get number() {
-        if (typeof this._value === "number") {
-            return this._value;
+        set value(value) {
+            this._value = value;
         }
-        throw "Field value is not a number";
-    }
-    async upload(buffer, filename, mime) {
-        let trace = new Error();
-        if (this.metadata.result !== "container")
-            throw "Cannot upload a file to the field; " + this.id + " (not a container field)";
-        let form = new FormData();
-        form.append("upload", new File([buffer], filename, { type: mime }));
-        let res = await this.parent.layout.database.apiRequestRaw(`${this.parent.endpoint}/containers/${this.id}/1`, {
-            method: "POST",
-            // @ts-ignore
-            body: form
-        });
-        if (!res.ok)
-            throw new Error(`Upload failed with HTTP error: ${res.status} (${res.statusText})`);
-    }
-    async download(mode = DownloadModes.Stream) {
-        if (this.metadata.result !== ApiFieldResultTypes.CONTAINER)
-            throw new Error("Cannot perform download() on a non-container field");
-        let stream = await this.parent.layout.database.streamURL(this.string);
-        if (mode === DownloadModes.Stream) {
-            return stream;
+        get string() {
+            if (typeof this._value === 'string') {
+                return this._value;
+            }
+            throw new Error('Field value is not a string');
         }
-        let body = [];
-        return new Promise((resolve, reject) => {
-            stream.on("data", chunk => {
-                body.push(chunk);
-            });
-            stream.on("error", (e) => {
-                reject(e);
+        /**
+         * 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);
+            console.log(`ENDPOINT: ${this.parent.endpoint}/containers/${this.id}/1`);
+            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
             });
-            stream.on("end", () => {
-                resolve({
-                    buffer: Buffer.concat(body),
-                    mime: stream.headers["content-type"],
-                    request: stream
+            if (!res.ok) {
+                console.log("RESULT:", await res.text());
+                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 {
+                console.log(data);
+                throw new FMError(data.messages[0].code, res.status, res);
+            }
+        }
+        get #streamAsync() { return _private_streamAsync_descriptor.value; }
+        stream() {
+            return this.#streamAsync();
+        }
+        async arrayBuffer() {
+            console.log(this.string);
+            const req = await this.parent.layout.database._apiRequestRaw(this.string, { useCookieJar: true });
+            if (!req.ok)
+                throw new Error(`HTTP Error: ${req.status} (${req.statusText})`);
+            console.log(req);
+            return await req.arrayBuffer();
+        }
+    };
+})();
+export { Field };
+function containerDownloadFunction(originalMethod, context) {
+    async function replacementMethod(...args) {
+        return ContainerDownloadExecutor.processTask(() => originalMethod.call(this, ...args));
+    }
+    return replacementMethod;
+}
+class ContainerDownloadExecutorClass {
+    hasDownloadedFirstContainer = 0;
+    waitingFuncs = [];
+    constructor() { }
+    async processTask(task) {
+        let isFirstTask = this.hasDownloadedFirstContainer === 0;
+        if (isFirstTask) {
+            this.hasDownloadedFirstContainer = 1;
+            let res;
+            try {
+                res = await task();
+            }
+            catch (e) {
+                this.hasDownloadedFirstContainer = 0;
+                let 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 (let task of this.waitingFuncs) {
+                task.func()
+                    .then((res) => task.done(res))
+                    .catch((e) => task.err(e));
+            }
+            return res;
+        }
+        else if (this.hasDownloadedFirstContainer === 1) {
+            return new Promise((resolve, reject) => {
+                this.waitingFuncs.push({
+                    func: task,
+                    done: resolve,
+                    err: reject
                 });
             });
-        });
+        }
+        else
+            return await task();
     }
 }
+const ContainerDownloadExecutor = new ContainerDownloadExecutorClass();