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

package/package.json

@@ -1,10 +1,12 @@
 {
   "name": "@jd-data-limited/easy-fm",
-  "version": "4.1.0",
+  "version": "4.1.1",
   "dependencies": {
     "@types/follow-redirects": "^1.14.4",
     "follow-redirects": "^1.15.5",
-    "moment": "^2.29.4"
+    "moment": "^2.29.4",
+    "node-fetch": "^3.3.2",
+    "node-fetch-cookies": "^2.1.1"
   },
   "type": "module",
   "main": "src/index.js",
@@ -49,6 +51,7 @@
     "eslint-plugin-promise": "^6.1.1",
     "inquirer": "^9.2.13",
     "ts-morph": "^21.0.1",
+    "typedoc": "^0.25.12",
     "typescript": "^5.4.3",
     "webpack": "^5.81.0",
     "webpack-cli": "^5.0.2"

package/src/connection/database.d.ts

@@ -1,5 +1,4 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" />
 import { EventEmitter } from 'events';
 import { type LayoutInterface } from '../layouts/layoutInterface.js';
 import { Layout } from '../layouts/layout.js';
@@ -8,7 +7,7 @@ import { type HostBase } from './HostBase.js';
 import { type DatabaseBase } from './databaseBase.js';
 import { type ApiResults } from '../models/apiResults.js';
 import { type DatabaseStructure } from '../databaseStructure.js';
-import { type IncomingMessage } from 'http';
+import { RequestInfo, RequestInit, Response } from 'node-fetch';
 /**
  * Represents a database connection.
  * @template T - The structure of the database.
@@ -38,7 +37,7 @@ export declare class Database<T extends DatabaseStructure> extends EventEmitter
      * @throws {FMError} - Throws an FMError if login fails.
      * @return {Promise<string>} - Returns a promise that resolves to the access token upon successful login.
      */
-    login(forceLogin?: boolean): Promise<string>;
+    login(forceLogin?: boolean): Promise<string | undefined>;
     get token(): string;
     /**
      * Returns the endpoint URL for the database connection.
@@ -46,10 +45,12 @@ export declare class Database<T extends DatabaseStructure> extends EventEmitter
      * @returns {string} The endpoint URL.
      */
     get endpoint(): string;
-    _apiRequestRaw(url: string | Request, options?: RequestInit & {
+    _apiRequestRaw(url: URL | RequestInfo, options?: RequestInit & {
         headers?: Record<string, string>;
+        useCookieJar?: boolean;
     }, autoRelogin?: boolean): Promise<Response>;
-    _apiRequestJSON<T = any>(url: string | Request, options?: RequestInit & {
+    private _generateCookieHeader;
+    _apiRequestJSON<T = any>(url: URL | RequestInfo, options?: RequestInit & {
         headers?: Record<string, string>;
     }): Promise<ApiResults<T>>;
     /**
@@ -62,5 +63,4 @@ export declare class Database<T extends DatabaseStructure> extends EventEmitter
     layout<R extends keyof T['layouts']>(name: R): Layout<T['layouts'][R]>;
     layout<R extends LayoutInterface>(name: string): Layout<R>;
     script(name: string, parameter?: string): Script;
-    streamURL(url: string): Promise<IncomingMessage>;
 }

package/src/connection/database.js

@@ -5,7 +5,9 @@ import { EventEmitter } from 'events';
 import { generateAuthorizationHeaders } from './generateAuthorizationHeaders.js';
 import { FMError } from '../FMError.js';
 import { Layout } from '../layouts/layout.js';
-import HTTP_REDIRECT from 'follow-redirects';
+import fetch from 'node-fetch';
+// @ts-ignore
+import fetchWithCookies, { CookieJar } from "node-fetch-cookies";
 /**
  * Represents a database connection.
  * @template T - The structure of the database.
@@ -14,7 +16,7 @@ export class Database extends EventEmitter {
     _token = '';
     host;
     connection_details;
-    cookies = {};
+    cookies = new CookieJar();
     name;
     debug;
     constructor(host, conn) {
@@ -67,12 +69,13 @@ export class Database extends EventEmitter {
      * @return {Promise<string>} - Returns a promise that resolves to the access token upon successful login.
      */
     async login(forceLogin = false) {
-        // console.trace()
+        if (this.token !== '' && !forceLogin)
+            return;
+        console.log("RELOGGING IN");
+        console.trace();
         // Reset cookies
-        this.cookies = {};
+        this.cookies = new CookieJar();
         await this.host.getMetadata();
-        if (this.token !== '' && !forceLogin)
-            throw new Error('Already logged in. Run logout() first');
         if (this.connection_details.credentials.method === 'token') {
             this._token = (this.connection_details.credentials).token;
             return this.token;
@@ -121,19 +124,38 @@ export class Database extends EventEmitter {
         if (!options.headers)
             options.headers = {};
         options.headers.authorization = 'Bearer ' + this._token;
+        // options.redirect = "manual"
+        // options.headers.cookies = this._generateCookieHeader()
+        // console.log(options.headers.cookies)
         // options.rejectUnauthorized = this.host.verify
-        const _fetch = await fetch(url, options);
-        if (_fetch.headers.get('set-cookie')) {
-            for (const cookie of _fetch.headers.get('set-cookie') ?? []) {
-                const cookieSplit = cookie.split('=');
-                this.cookies[cookieSplit[0]] = cookieSplit[1];
-            }
-        }
+        const _fetch = options.useCookieJar ?
+            await fetchWithCookies(this.cookies, url, options) :
+            await fetch(url, options);
+        // if (_fetch.headers.get('set-cookie')) {
+        //     console.log(_fetch.headers.get('set-cookie'))
+        //     for (const cookie of (_fetch.headers.get("Set-Cookie") ?? "").split("; ")) {
+        //         const cookieSplit = cookie.split('=')
+        //         console.log("COOKIE SPLIT:", cookieSplit)
+        //         if (cookieSplit[1]) this.cookies[cookieSplit[0]] = cookieSplit[1]
+        //     }
+        // }
+        // console.log(this.cookies, _fetch.status)
+        // // console.log(this, this.cookies, url)
+        // console.trace()
         if (_fetch.status === 401 && autoRelogin) {
+            console.trace();
             await this.login(true);
             return await this._apiRequestRaw(url, options, false);
         }
-        return _fetch;
+        else
+            return _fetch;
+    }
+    _generateCookieHeader() {
+        let out = [];
+        for (let key of Object.keys(this.cookies)) {
+            out.push(`${key}=${this.cookies[key]}`);
+        }
+        return out.join("; ");
     }
     async _apiRequestJSON(url, options = {}) {
         if (!options.headers)
@@ -179,37 +201,4 @@ export class Database extends EventEmitter {
     script(name, parameter = '') {
         return ({ name, parameter });
     }
-    async streamURL(url) {
-        return await new Promise((resolve, reject) => {
-            if (!url || typeof url !== 'string') {
-                throw new Error('URL is empty, or has invalid value');
-            }
-            const headers = {};
-            if (Object.keys(this.cookies).length !== 0) {
-                headers.Cookie = Object.keys(this.cookies)
-                    .map(key => {
-                    return key + '=' + this.cookies[key];
-                })
-                    .join('; ');
-            }
-            const checkForCookies = (res) => {
-                // Check for the 'set-cookie' header. If it exists, remember it and strip it for better security.
-                if (res.headers['set-cookie']) {
-                    for (const cookie of res.headers['set-cookie']) {
-                        const cookieSplit = cookie.split('=');
-                        this.cookies[cookieSplit[0]] = cookieSplit[1];
-                    }
-                    res.headers['set-cookie'] = undefined;
-                }
-            };
-            // Automatically switch between the http and https modules, based on which is needed
-            (url.startsWith('https') ? HTTP_REDIRECT.https : HTTP_REDIRECT.http).get(url, {
-                headers,
-                beforeRedirect: (options, res) => { checkForCookies(res); }
-            }, (res) => {
-                checkForCookies(res);
-                resolve(res);
-            });
-        });
-    }
 }

package/src/connection/database.ts

@@ -7,13 +7,14 @@ import {generateAuthorizationHeaders} from './generateAuthorizationHeaders.js'
 import {FMError} from '../FMError.js'
 import {type LayoutInterface} from '../layouts/layoutInterface.js'
 import {Layout} from '../layouts/layout.js'
-import HTTP_REDIRECT from 'follow-redirects'
 import {type databaseOptionsBase, type databaseOptionsWithExternalSources, type Script} from '../types.js'
 import {type HostBase} from './HostBase.js'
 import {type DatabaseBase} from './databaseBase.js'
 import {type ApiLayout, type ApiResults} from '../models/apiResults.js'
 import {type DatabaseStructure} from '../databaseStructure.js'
-import {type IncomingMessage} from 'http'
+import fetch, {HeadersInit, RequestInfo, RequestInit, Response} from 'node-fetch';
+// @ts-ignore
+import fetchWithCookies, {CookieJar} from "node-fetch-cookies"
 
 /**
  * Represents a database connection.
@@ -23,11 +24,11 @@ export class Database<T extends DatabaseStructure> extends EventEmitter implemen
     private _token: string = ''
     readonly host: HostBase
     private readonly connection_details: databaseOptionsWithExternalSources
-    private cookies: Record<string, string> = {}
+    private cookies = new CookieJar()
     readonly name: string
     readonly debug: boolean
 
-    constructor (host: HostBase, conn: databaseOptionsWithExternalSources) {
+    constructor(host: HostBase, conn: databaseOptionsWithExternalSources) {
         super()
         this.host = host
         this.name = conn.database
@@ -36,7 +37,7 @@ export class Database<T extends DatabaseStructure> extends EventEmitter implemen
     }
 
     // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-    private generateExternalSourceLogin (data: databaseOptionsBase) {
+    private generateExternalSourceLogin(data: databaseOptionsBase) {
         if (data.credentials.method === 'filemaker') {
             const _data = data.credentials
             return {
@@ -44,7 +45,8 @@ export class Database<T extends DatabaseStructure> extends EventEmitter implemen
                 username: _data.username,
                 password: _data.password
             }
-        } else {
+        }
+        else {
             throw new Error('Not yet supported login method')
         }
     }
@@ -56,7 +58,7 @@ export class Database<T extends DatabaseStructure> extends EventEmitter implemen
      * @returns {Promise<void>} A promise that resolves with no value once the logout is successful.
      * @throws {Error} Throws an error if the user is not logged in.
      */
-    async logout (): Promise<void> {
+    async logout(): Promise<void> {
         if (this.token === '') throw new Error('Not logged in')
 
         const _fetch = await fetch(`${this.endpoint}/sessions/${this.token}`, {
@@ -78,18 +80,21 @@ export class Database<T extends DatabaseStructure> extends EventEmitter implemen
      * @throws {FMError} - Throws an FMError if login fails.
      * @return {Promise<string>} - Returns a promise that resolves to the access token upon successful login.
      */
-    async login (forceLogin = false) {
-        // console.trace()
+    async login(forceLogin = false) {
+        if (this.token !== '' && !forceLogin) return
+
+        console.log("RELOGGING IN")
+        console.trace()
         // Reset cookies
-        this.cookies = {}
+        this.cookies = new CookieJar()
 
         await this.host.getMetadata()
-        if (this.token !== '' && !forceLogin) throw new Error('Already logged in. Run logout() first')
 
         if (this.connection_details.credentials.method === 'token') {
             this._token = (this.connection_details.credentials).token
             return this.token
-        } else {
+        }
+        else {
             console.time()
             const url = new URL(`${this.endpoint}/sessions`)
             url.hostname = this.host.hostname
@@ -104,11 +109,12 @@ export class Database<T extends DatabaseStructure> extends EventEmitter implemen
                 })
             })
             console.time()
-            const _res = (await res.json())
+            const _res = (await res.json()) as any
             if (res.status === 200) {
                 this._token = res.headers.get('x-fm-data-access-token') ?? ''
                 return this._token
-            } else {
+            }
+            else {
                 throw new FMError(
                     _res.messages[0].code as string | number,
                     _res.status as number,
@@ -118,7 +124,7 @@ export class Database<T extends DatabaseStructure> extends EventEmitter implemen
         }
     }
 
-    get token () {
+    get token() {
         return this._token
     }
 
@@ -127,34 +133,58 @@ export class Database<T extends DatabaseStructure> extends EventEmitter implemen
      *
      * @returns {string} The endpoint URL.
      */
-    get endpoint (): string {
+    get endpoint(): string {
         return `${this.host.hostname}/fmi/data/v2/databases/${this.name}`
     }
 
-    async _apiRequestRaw (url: string | Request, options: RequestInit & { headers?: Record<string, string> } = {}, autoRelogin = true): Promise<Response> {
+    async _apiRequestRaw(url: URL | RequestInfo, options: RequestInit & {
+        headers?: Record<string, string>,
+        useCookieJar?: boolean,
+    } = {}, autoRelogin = true): Promise<Response> {
         if (this.debug) console.log(`EASYFM DEBUG: ${JSON.stringify(options)} ${url instanceof Request ? url.url : url}`)
         if (this.token === '') await this.login(true)
 
         if (!options.headers) options.headers = {}
         options.headers.authorization = 'Bearer ' + this._token
+        // options.redirect = "manual"
+        // options.headers.cookies = this._generateCookieHeader()
+        // console.log(options.headers.cookies)
         // options.rejectUnauthorized = this.host.verify
 
-        const _fetch = await fetch(url, options)
-        if (_fetch.headers.get('set-cookie')) {
-            for (const cookie of _fetch.headers.get('set-cookie') ?? []) {
-                const cookieSplit = cookie.split('=')
-                this.cookies[cookieSplit[0]] = cookieSplit[1]
-            }
-        }
-
+        const _fetch: Response =
+            options.useCookieJar ?
+                await fetchWithCookies(this.cookies, url, options):
+                await fetch(url, options)
+        // if (_fetch.headers.get('set-cookie')) {
+        //     console.log(_fetch.headers.get('set-cookie'))
+        //     for (const cookie of (_fetch.headers.get("Set-Cookie") ?? "").split("; ")) {
+        //         const cookieSplit = cookie.split('=')
+        //         console.log("COOKIE SPLIT:", cookieSplit)
+        //         if (cookieSplit[1]) this.cookies[cookieSplit[0]] = cookieSplit[1]
+        //     }
+        // }
+        // console.log(this.cookies, _fetch.status)
+        // // console.log(this, this.cookies, url)
+        // console.trace()
         if (_fetch.status === 401 && autoRelogin) {
+            console.trace()
             await this.login(true)
             return await this._apiRequestRaw(url, options, false)
         }
-        return _fetch
+        else return _fetch
+    }
+
+    private _generateCookieHeader() {
+        let out: string[] = []
+        for (let key of Object.keys(this.cookies)) {
+            out.push(`${key}=${this.cookies[key]}`)
+        }
+        return out.join("; ")
     }
 
-    async _apiRequestJSON<T = any>(url: string | Request, options: RequestInit & { headers?: Record<string, string> } = {}): Promise<ApiResults<T>> {
+    async _apiRequestJSON<T = any>(url: URL | RequestInfo, options: RequestInit & {
+        headers?: Record<string, string>
+    } = {}): Promise<ApiResults<T>> {
         if (!options.headers) options.headers = {}
         options.headers['content-type'] = options.headers['content-type'] ? options.headers['content-type'] : 'application/json'
         const _fetch = await this._apiRequestRaw(url, options)
@@ -178,7 +208,7 @@ export class Database<T extends DatabaseStructure> extends EventEmitter implemen
      * @returns {Promise<Layout[]>} A promise that resolves to an array of Layout objects.
      * @throws {FMError} If there was an error retrieving the layouts.
      */
-    async listLayouts () {
+    async listLayouts() {
         const req = await this._apiRequestJSON<{ layouts: ApiLayout[] }>(`${this.endpoint}/layouts?page=2`)
         if (!req.response) throw new FMError(req.messages[0].code, req.httpStatus, req.messages[0].message)
 
@@ -195,49 +225,11 @@ export class Database<T extends DatabaseStructure> extends EventEmitter implemen
 
     layout<R extends keyof T['layouts']>(name: R): Layout<T['layouts'][R]>
     layout<R extends LayoutInterface>(name: string): Layout<R>
-    layout (name: string): Layout<any> {
+    layout(name: string): Layout<any> {
         return new Layout<LayoutInterface>(this, name)
     }
 
-    script (name: string, parameter = ''): Script {
-        return ({ name, parameter } satisfies Script)
-    }
-
-    async streamURL (url: string): Promise<IncomingMessage> {
-        return await new Promise((resolve, reject) => {
-            if (!url || typeof url !== 'string') {
-                throw new Error('URL is empty, or has invalid value')
-            }
-
-            const headers: Record<string, string> = {}
-            if (Object.keys(this.cookies).length !== 0) {
-                headers.Cookie = Object.keys(this.cookies)
-                    .map(key => {
-                        return key + '=' + this.cookies[key]
-                    })
-                    .join('; ')
-            }
-
-            const checkForCookies = (res: HTTP_REDIRECT.ResponseDetails) => {
-                // Check for the 'set-cookie' header. If it exists, remember it and strip it for better security.
-                if (res.headers['set-cookie']) {
-                    for (const cookie of res.headers['set-cookie']) {
-                        const cookieSplit = cookie.split('=')
-                        this.cookies[cookieSplit[0]] = cookieSplit[1]
-                    }
-                    res.headers['set-cookie'] = undefined
-                }
-            }
-
-            // Automatically switch between the http and https modules, based on which is needed
-            (url.startsWith('https') ? HTTP_REDIRECT.https : HTTP_REDIRECT.http).get(url, {
-                headers,
-                beforeRedirect: (options: any, res: HTTP_REDIRECT.ResponseDetails) => { checkForCookies(res) }
-            }, (res) => {
-                checkForCookies(res)
-
-                resolve(res)
-            })
-        })
+    script(name: string, parameter = ''): Script {
+        return ({name, parameter} satisfies Script)
     }
 }

package/src/connection/databaseBase.d.ts

@@ -1,17 +1,16 @@
-/// <reference types="node" resolution-mode="require"/>
 import { type HostBase } from './HostBase.js';
 import { type ApiResults } from '../models/apiResults.js';
-import { type IncomingMessage } from 'http';
+import { RequestInfo, RequestInit, Response } from "node-fetch";
 export interface DatabaseBase {
     host: HostBase;
     readonly name: string;
     endpoint: string;
     token: string;
-    _apiRequestJSON: <T = unknown>(url: string | Request, options?: RequestInit & {
+    _apiRequestJSON: <T = unknown>(url: URL | RequestInfo, options?: RequestInit & {
         headers?: Record<string, string>;
     } | undefined, autoRelogin?: boolean) => Promise<ApiResults<T>>;
-    _apiRequestRaw: (url: string | Request, options?: RequestInit & {
+    _apiRequestRaw: (url: URL | RequestInfo, options?: RequestInit & {
         headers?: Record<string, string>;
+        useCookieJar?: boolean;
     } | undefined) => Promise<Response>;
-    streamURL: (url: string) => Promise<IncomingMessage>;
 }

package/src/connection/databaseBase.ts

@@ -4,7 +4,7 @@
 
 import {type HostBase} from './HostBase.js'
 import {type ApiResults} from '../models/apiResults.js'
-import {type IncomingMessage} from 'http'
+import {RequestInfo, RequestInit, Response} from "node-fetch";
 
 export interface DatabaseBase {
     host: HostBase
@@ -14,7 +14,6 @@ export interface DatabaseBase {
 
     // layouts: DatabaseStructure["layouts"]
 
-    _apiRequestJSON: <T = unknown>(url: string | Request, options?: RequestInit & { headers?: Record<string, string> } | undefined, autoRelogin?: boolean) => Promise<ApiResults<T>>
-    _apiRequestRaw: (url: string | Request, options?: RequestInit & { headers?: Record<string, string> } | undefined) => Promise<Response>
-    streamURL: (url: string) => Promise<IncomingMessage>
+    _apiRequestJSON: <T = unknown>(url: URL | RequestInfo, options?: RequestInit & { headers?: Record<string, string> } | undefined, autoRelogin?: boolean) => Promise<ApiResults<T>>
+    _apiRequestRaw: (url: URL | RequestInfo, options?: RequestInit & { headers?: Record<string, string>, useCookieJar?: boolean } | undefined) => Promise<Response>
 }

package/src/records/field.d.ts

@@ -1,7 +1,5 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
-import type * as http from 'http';
-import { type ContainerBufferResult, DownloadModes, RecordTypes } from '../types.js';
+/// <reference types="node" />
+import { RecordTypes } from '../types.js';
 import { type ApiFieldMetadata } from '../models/apiResults.js';
 import { type LayoutBase } from '../layouts/layoutBase.js';
 import { type Moment } from 'moment';
@@ -21,10 +19,12 @@ export interface Parentable {
  * @template T - The type of the field value.
  */
 export declare class Field<T extends FieldValue> {
+    #private;
     parent: Parentable;
     id: string;
     protected _value: T | null;
     edited: boolean;
+    static firstContainerDownload: Promise<any> | null;
     constructor(record: Parentable, id: string, contents: T);
     /**
      * Sets the value of the field.
@@ -40,22 +40,14 @@ export declare class Field<T extends FieldValue> {
     /**
      * Uploads a file to the container field.
      *
-     * @param {Buffer} buffer - The file content as a buffer.
-     * @param {string} filename - The filename of the file.
-     * @param {string} mime - The MIME type of the file.
+     * @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(buffer: Buffer, filename: string, mime: string): Promise<void>;
-    /**
-     * Downloads a resource from the server using the specified download mode.
-     *
-     * @param {DownloadModes} mode - The mode to use for downloading the resource.
-     * @return {Promise<http.IncomingMessage>} - A promise that resolves with the incoming message representing the downloaded resource.
-     */
-    download(mode: DownloadModes.Stream): Promise<http.IncomingMessage>;
-    download(mode: DownloadModes.Buffer): Promise<ContainerBufferResult>;
+    upload(file: File): Promise<void>;
+    stream(): Promise<NodeJS.ReadableStream>;
+    arrayBuffer(): Promise<ArrayBuffer>;
 }

package/src/records/field.js

@@ -1,60 +1,100 @@
 /*
  * Copyright (c) 2023-2024. See LICENSE file for more information
  */
-import { DownloadModes, RecordTypes } from '../types.js';
+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 { FMError } from "../FMError.js";
 /**
  * A class representing a field in a record.
  *
  * @template T - The type of the field value.
  */
-export class Field {
-    parent;
-    id;
-    _value;
-    edited;
-    constructor(record, id, contents) {
-        this.parent = record;
-        this.id = id;
-        this._value = contents;
-        this.edited = false;
-    }
-    /**
-     * 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 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: ''
-            };
+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 });
+        }
+        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;
         }
-        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) ??
-                {
+        /**
+         * 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 metadata() {
+            if (!this.parent.layout.metadata) {
+                // Default to a regular text field
+                return {
                     name: this.id.toString(),
                     type: ApiFieldTypes.NORMAL,
                     displayType: ApiFieldDisplayTypes.EDIT_TEXT,
@@ -70,90 +110,157 @@ export class Field {
                     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: ''
+                };
+            }
         }
-        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: ''
-            };
-        }
-    }
-    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') {
+        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 new Error('Field value is not a string');
-    }
-    /**
-     * Uploads a file to the container field.
-     *
-     * @param {Buffer} buffer - The file content as a buffer.
-     * @param {string} filename - The filename of the file.
-     * @param {string} mime - The MIME type of the file.
-     *
-     * @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(buffer, filename, mime) {
-        if (this.metadata.result !== 'container') {
-            throw new Error('Cannot upload a file to the field; ' + this.id + ' (not a container field)');
+        set value(value) {
+            this._value = value;
         }
-        const form = new FormData();
-        form.append('upload', new File([buffer], filename, { type: mime }));
-        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})`);
-    }
-    async download(mode = DownloadModes.Stream) {
-        if (this.metadata.result !== ApiFieldResultTypes.CONTAINER)
-            throw new Error('Cannot perform download() on a non-container field');
-        const 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');
         }
-        const body = [];
-        return await new Promise((resolve, reject) => {
-            stream.on('data', (chunk) => {
-                body.push(chunk);
+        /**
+         * 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('error', (e) => {
-                reject(e);
-            });
-            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();

package/src/records/field.ts

@@ -2,11 +2,11 @@
  * Copyright (c) 2023-2024. See LICENSE file for more information
  */
 
-import type * as http from 'http'
-import {type ContainerBufferResult, DownloadModes, RecordTypes} from '../types.js'
+import {RecordTypes} from '../types.js'
 import {ApiFieldDisplayTypes, type ApiFieldMetadata, ApiFieldResultTypes, ApiFieldTypes} from '../models/apiResults.js'
 import {type LayoutBase} from '../layouts/layoutBase.js'
 import {type Moment} from 'moment'
+import {FMError} from "../FMError.js";
 
 export type FieldValue = string | number | Moment | Container
 export type Container = null
@@ -29,7 +29,9 @@ export class Field<T extends FieldValue> {
     protected _value: T | null
     edited: boolean
 
-    constructor (record: Parentable, id: string, contents: T) {
+    static firstContainerDownload: Promise<any> | null = null
+
+    constructor(record: Parentable, id: string, contents: T) {
         this.parent = record
         this.id = id
         this._value = contents
@@ -42,13 +44,13 @@ export class Field<T extends FieldValue> {
      * @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: T | null) {
+    set(content: T | null) {
         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 metadata (): ApiFieldMetadata {
+    get metadata(): ApiFieldMetadata {
         if (!this.parent.layout.metadata) {
             // Default to a regular text field
             return {
@@ -86,7 +88,8 @@ export class Field<T extends FieldValue> {
                     repetitions: 1,
                     valueList: ''
                 }
-        } else {
+        }
+        else {
             return this.parent.layout.metadata.fieldMetaData.find(i => i.name === this.id) ?? {
                 name: this.id.toString(),
                 type: ApiFieldTypes.NORMAL,
@@ -106,16 +109,16 @@ export class Field<T extends FieldValue> {
         }
     }
 
-    get value (): T | null {
+    get value(): T | null {
         // 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: T) {
+    set value(value: T) {
         this._value = value
     }
 
-    get string (): string {
+    get string(): string {
         if (typeof this._value === 'string') {
             return this._value
         }
@@ -125,64 +128,118 @@ export class Field<T extends FieldValue> {
     /**
      * Uploads a file to the container field.
      *
-     * @param {Buffer} buffer - The file content as a buffer.
-     * @param {string} filename - The filename of the file.
-     * @param {string} mime - The MIME type of the file.
+     * @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 (buffer: Buffer, filename: string, mime: string): Promise<void> {
+    async upload(file: File): Promise<void> {
         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', new File([buffer], filename, {type: mime}))
+        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'
+                // 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})`)
+        if (!res.ok) {
+            console.log("RESULT:", await res.text())
+            throw new Error(`Upload failed with HTTP error: ${res.status} (${res.statusText})`)
+        }
+        const data: { messages: Array<{ code: string }> } = await res.json() as any
+        if (data.messages[0].code === "0") return
+        else {
+            console.log(data)
+            throw new FMError(data.messages[0].code, res.status, res)
+        }
     }
 
-    /**
-     * Downloads a resource from the server using the specified download mode.
-     *
-     * @param {DownloadModes} mode - The mode to use for downloading the resource.
-     * @return {Promise<http.IncomingMessage>} - A promise that resolves with the incoming message representing the downloaded resource.
-     */
-    download (mode: DownloadModes.Stream): Promise<http.IncomingMessage>
-    download (mode: DownloadModes.Buffer): Promise<ContainerBufferResult>
-    async download (mode: DownloadModes = DownloadModes.Stream): Promise<http.IncomingMessage | ContainerBufferResult> {
-        if (this.metadata.result !== ApiFieldResultTypes.CONTAINER) throw new Error('Cannot perform download() on a non-container field')
-
-        const stream = await this.parent.layout.database.streamURL(this.string)
-        if (mode === DownloadModes.Stream) {
-            return stream
+    @containerDownloadFunction
+    async #streamAsync() {
+        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
+    }
 
-        const body: Uint8Array[] = []
-        return await new Promise((resolve, reject) => {
-            stream.on('data', (chunk: Uint8Array) => {
-                body.push(chunk)
-            })
-            stream.on('error', (e) => {
-                reject(e)
-            })
-            stream.on('end', () => {
-                resolve({
-                    buffer: Buffer.concat(body),
-                    mime: stream.headers['content-type'],
-                    request: stream
-                } satisfies ContainerBufferResult)
+    stream() {
+        return this.#streamAsync()
+    }
+
+    @containerDownloadFunction
+    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()
+    }
+}
+
+function containerDownloadFunction<T extends FieldValue, R = unknown>(originalMethod: (...p: any[]) => Promise<R>, context: ClassMethodDecoratorContext<Field<T>>) {
+    async function replacementMethod(this: Field<T>, ...args: any[]) {
+        return ContainerDownloadExecutor.processTask(() => originalMethod.call(this, ...args))
+    }
+
+    return replacementMethod
+}
+
+class ContainerDownloadExecutorClass {
+    hasDownloadedFirstContainer: 0 | 1 | 2 = 0
+    waitingFuncs: {
+        func: (() => any),
+        done: ((...args: any[]) => any),
+        err: ((e: Error) => any)
+    }[] = []
+
+    constructor() {}
+
+    async processTask<T extends () => Promise<any>>(task: T) {
+        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: any) => task.done(res))
+                    .catch((e: any) => 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()

package/src/records/getOperations/recordGetOperation.js

@@ -135,6 +135,7 @@ export class RecordGetOperation {
                         ? this.layout.database.host.timeFormat
                         : this.layout.database.host.timeStampFormat);
             }).join('');
+            console.log(this.layout.database.host.timeStampFormat, out[key]);
         }
         return out;
     }

package/src/records/getOperations/recordGetOperation.ts

@@ -165,6 +165,7 @@ export class RecordGetOperation<T extends LayoutInterface, OPTIONS extends GetOp
                                 : this.layout.database.host.timeStampFormat
                     )
             }).join('')
+            console.log(this.layout.database.host.timeStampFormat, out[key])
         }
         return out
     }

package/src/records/recordBase.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" />
 import { EventEmitter } from 'events';
 import { RecordTypes } from '../types.js';
 import { type RecordFieldsMap } from '../layouts/recordFieldsMap.js';

package/src/types.d.ts

@@ -1,5 +1,5 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" />
+/// <reference types="node" />
 import type * as http from 'http';
 import { type FMError } from './FMError.js';
 import { type LayoutInterface } from './layouts/layoutInterface.js';
@@ -52,10 +52,6 @@ export interface ScriptRequestData {
 export interface extraBodyOptions {
     scripts?: ScriptRequestData;
 }
-export declare enum DownloadModes {
-    Stream = 0,
-    Buffer = 1
-}
 export interface Script {
     name: string;
     parameter: string;

package/src/types.js

@@ -1,11 +1,6 @@
 /*
  * Copyright (c) 2022-2024. See LICENSE file for more information
  */
-export var DownloadModes;
-(function (DownloadModes) {
-    DownloadModes[DownloadModes["Stream"] = 0] = "Stream";
-    DownloadModes[DownloadModes["Buffer"] = 1] = "Buffer";
-})(DownloadModes || (DownloadModes = {}));
 export var RecordTypes;
 (function (RecordTypes) {
     RecordTypes[RecordTypes["UNKNOWN"] = 0] = "UNKNOWN";

package/src/types.ts

@@ -65,11 +65,6 @@ export interface extraBodyOptions {
     scripts?: ScriptRequestData
 }
 
-export enum DownloadModes {
-    Stream,
-    Buffer
-}
-
 export interface Script {
     name: string
     parameter: string