@jd-data-limited/easy-fm 4.1.2 → 4.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jd-data-limited/easy-fm",
-  "version": "4.1.2",
+  "version": "4.1.4",
   "dependencies": {
     "@types/follow-redirects": "^1.14.4",
     "follow-redirects": "^1.15.5",

package/src/bin/generateTypes.js

@@ -1,10 +1,53 @@
+"use strict";
 /*
  * Copyright (c) 2024. See LICENSE file for more information
  */
-import { ApiFieldResultTypes } from "../models/apiResults.js";
-import inquirer from 'inquirer';
-import FMHost from "../connection/FMHost.js";
-import * as fs from "fs";
+var __makeTemplateObject = (this && this.__makeTemplateObject) || function (cooked, raw) {
+    if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
+    return cooked;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTypesCLI = void 0;
+var apiResults_js_1 = require("../models/apiResults.js");
+var inquirer_1 = require("inquirer");
+var FMHost_js_1 = require("../connection/FMHost.js");
+var fs = require("fs");
 function sub(str) {
     return str
         .replace(/[^a-zA-Z0-9_]/g, "") // Remove non-alphanumeric characters
@@ -12,38 +55,42 @@ function sub(str) {
 }
 function generateFieldType(field) {
     switch (field.result) {
-        case ApiFieldResultTypes.TEXT:
+        case apiResults_js_1.ApiFieldResultTypes.TEXT:
             return "Field<string>";
-        case ApiFieldResultTypes.CONTAINER:
+        case apiResults_js_1.ApiFieldResultTypes.CONTAINER:
             return "Field<Container>";
-        case ApiFieldResultTypes.DATE:
+        case apiResults_js_1.ApiFieldResultTypes.DATE:
             return "Field<Date>";
-        case ApiFieldResultTypes.NUMBER:
+        case apiResults_js_1.ApiFieldResultTypes.NUMBER:
             return "Field<number>";
-        case ApiFieldResultTypes.TIME:
+        case apiResults_js_1.ApiFieldResultTypes.TIME:
             return "Field<Date>";
-        case ApiFieldResultTypes.TIMESTAMP:
+        case apiResults_js_1.ApiFieldResultTypes.TIMESTAMP:
             return "Field<Date>";
     }
 }
 function processFieldsChunk(fields) {
-    let existing_fields = [];
-    fields = fields.filter(field => {
+    var existing_fields = [];
+    fields = fields.filter(function (field) {
         if (existing_fields.includes(field.name))
             return false;
         existing_fields.push(field.name);
         return true;
     });
-    return fields.map(field => {
+    return fields.map(function (field) {
         return JSON.stringify(field.name) + ": " + generateFieldType(field);
     });
 }
 function camelToSnakeCase(str) {
     return str.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toLowerCase();
 }
-function safeStringInjection(str, ...args) {
-    let result = "";
-    for (let i = 0; i < str.length; i++) {
+function safeStringInjection(str) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+    }
+    var result = "";
+    for (var i = 0; i < str.length; i++) {
         result += str[i];
         if (i < args.length) {
             result += JSON.stringify(args[i].toString());
@@ -51,111 +98,158 @@ function safeStringInjection(str, ...args) {
     }
     return result;
 }
-export async function generateTypesCLI() {
-    process.stdout.write('\x1Bc');
-    console.log("For this tool to work, you are required to have access to an account on the target database.\n" +
-        "This account must have the fmrest extended privilege enabled.\n" +
-        "This tool can only export type interfaces for layouts that the given account has access to.");
-    console.log("\n");
-    const data = await inquirer.prompt([
-        {
-            type: "input",
-            name: "hostname",
-            message: "The IP address/domain of your FileMaker server (must start with either http:// or https://)",
-            validate(input) {
-                return input.startsWith("http://") || input.startsWith("https://") || "Please enter a valid IP address/domain starting with http:// or https://";
-            }
-        },
-        {
-            type: "number",
-            name: "timezoneOffset",
-            message: "Server timezone offset (minutes)",
-            default: 0 - (new Date()).getTimezoneOffset()
-        },
-        {
-            type: "confirm",
-            name: "verify",
-            default: true,
-            message: "Verify your server's identity",
-            when(previousAnswers) {
-                return previousAnswers.hostname.startsWith("https://");
+function generateTypesCLI() {
+    return __awaiter(this, void 0, void 0, function () {
+        var data, HOST, DATABASE, stream, layouts, layoutInterfaces, _loop_1, _i, layouts_1, layout, layoutInterfaceLinks, _a, layoutInterfaces_1, layout, _b, layoutInterfaces_2, layout;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    process.stdout.write('\x1Bc');
+                    console.log("For this tool to work, you are required to have access to an account on the target database.\n" +
+                        "This account must have the fmrest extended privilege enabled.\n" +
+                        "This tool can only export type interfaces for layouts that the given account has access to.");
+                    console.log("\n");
+                    return [4 /*yield*/, inquirer_1.default.prompt([
+                            {
+                                type: "input",
+                                name: "hostname",
+                                message: "The IP address/domain of your FileMaker server (must start with either http:// or https://)",
+                                validate: function (input) {
+                                    return input.startsWith("http://") || input.startsWith("https://") || "Please enter a valid IP address/domain starting with http:// or https://";
+                                }
+                            },
+                            {
+                                type: "number",
+                                name: "timezoneOffset",
+                                message: "Server timezone offset (minutes)",
+                                default: 0 - (new Date()).getTimezoneOffset()
+                            },
+                            {
+                                type: "confirm",
+                                name: "verify",
+                                default: true,
+                                message: "Verify your server's identity",
+                                when: function (previousAnswers) {
+                                    return previousAnswers.hostname.startsWith("https://");
+                                }
+                            },
+                            {
+                                type: "input",
+                                name: "database",
+                                message: "Database filename"
+                            },
+                            {
+                                type: "input",
+                                name: "username",
+                                message: "Database username"
+                            },
+                            {
+                                type: "password",
+                                name: "password",
+                                message: "Database password",
+                                mask: "*"
+                            }
+                        ])];
+                case 1:
+                    data = _c.sent();
+                    HOST = new FMHost_js_1.default(data.hostname, data.timezoneOffset, data.verify);
+                    DATABASE = HOST.database({
+                        database: data.database,
+                        credentials: {
+                            method: "filemaker",
+                            username: data.username,
+                            password: data.password
+                        },
+                        externalSources: []
+                    });
+                    return [4 /*yield*/, DATABASE.login()
+                        // Create file write stream
+                    ];
+                case 2:
+                    _c.sent();
+                    stream = fs.createWriteStream("./types.ts");
+                    return [4 /*yield*/, DATABASE.listLayouts()];
+                case 3:
+                    layouts = _c.sent();
+                    stream.write("import FMHost, {Container, FieldBase, LayoutInterface, Portal} from \"@jd-data-limited/easy-fm\";\n");
+                    stream.write("// " + layouts.length + " layouts found\n\n");
+                    layoutInterfaces = new Map();
+                    _loop_1 = function (layout) {
+                        var substituteName, metadata, fields, portals, portalsProcessed, interfaceName;
+                        return __generator(this, function (_d) {
+                            switch (_d.label) {
+                                case 0:
+                                    substituteName = sub(layout.name);
+                                    if (!substituteName)
+                                        return [2 /*return*/, "continue"];
+                                    console.log(substituteName);
+                                    return [4 /*yield*/, layout.getLayoutMeta()];
+                                case 1:
+                                    metadata = _d.sent();
+                                    fields = processFieldsChunk(metadata.fieldMetaData);
+                                    portals = metadata.portalMetaData;
+                                    portalsProcessed = Object.keys(portals).map(function (portalName) {
+                                        return "".concat(JSON.stringify(portalName), ": Portal<{").concat(processFieldsChunk(portals[portalName]), "}>");
+                                    });
+                                    interfaceName = substituteName + "LayoutInterface";
+                                    layoutInterfaces.set(layout.name, {
+                                        interfaceName: interfaceName,
+                                        interface: "export interface ".concat(interfaceName, " extends LayoutInterface {\n            fields: {").concat(fields.join(",\n    "), "},\n            portals: {").concat(portalsProcessed.join(",\n   "), "}\n        }")
+                                    });
+                                    return [2 /*return*/];
+                            }
+                        });
+                    };
+                    _i = 0, layouts_1 = layouts;
+                    _c.label = 4;
+                case 4:
+                    if (!(_i < layouts_1.length)) return [3 /*break*/, 7];
+                    layout = layouts_1[_i];
+                    return [5 /*yield**/, _loop_1(layout)];
+                case 5:
+                    _c.sent();
+                    _c.label = 6;
+                case 6:
+                    _i++;
+                    return [3 /*break*/, 4];
+                case 7:
+                    layoutInterfaceLinks = [];
+                    for (_a = 0, layoutInterfaces_1 = layoutInterfaces; _a < layoutInterfaces_1.length; _a++) {
+                        layout = layoutInterfaces_1[_a];
+                        layoutInterfaceLinks.push([
+                            "".concat(JSON.stringify(layout[0]), ": ").concat(layout[1].interfaceName),
+                            "".concat(sub(camelToSnakeCase(layout[0]).toUpperCase().replace(" ", "_")), ": HOST.getLayout<").concat(layout[1].interfaceName, ">(").concat(JSON.stringify(layout[0]), ")")
+                        ]);
+                    }
+                    stream.write(safeStringInjection(templateObject_1 || (templateObject_1 = __makeTemplateObject(["const HOST = new FMHost(", ", ", ", ", ");"], ["const HOST = new FMHost(", ", ", ", ", ");"])), data.hostname, data.timezoneOffset, data.verify));
+                    stream.write("HOST.database<{layouts:{".concat(layoutInterfaceLinks.map(function (i) { return i[0]; }).join(","), "}}>();"));
+                    stream.write("\n\n");
+                    stream.write("const LAYOUTS = {".concat(layoutInterfaceLinks.map(function (i) { return i[1]; }).join(","), "};"));
+                    for (_b = 0, layoutInterfaces_2 = layoutInterfaces; _b < layoutInterfaces_2.length; _b++) {
+                        layout = layoutInterfaces_2[_b];
+                        stream.write("\n\n");
+                        stream.write(layout[1].interface + ";");
+                    }
+                    // StructureKind
+                    //
+                    // const project = new Project({
+                    //     tsConfigFilePath: "../tsconfig.json"
+                    // })
+                    // project.resolveSourceFileDependencies()
+                    return [4 /*yield*/, DATABASE.logout()];
+                case 8:
+                    // StructureKind
+                    //
+                    // const project = new Project({
+                    //     tsConfigFilePath: "../tsconfig.json"
+                    // })
+                    // project.resolveSourceFileDependencies()
+                    _c.sent();
+                    console.log("DONE! Wrote database types to ./types.ts");
+                    return [2 /*return*/];
             }
-        },
-        {
-            type: "input",
-            name: "database",
-            message: "Database filename"
-        },
-        {
-            type: "input",
-            name: "username",
-            message: "Database username"
-        },
-        {
-            type: "password",
-            name: "password",
-            message: "Database password",
-            mask: "*"
-        }
-    ]);
-    const HOST = new FMHost(data.hostname, data.timezoneOffset, data.verify);
-    const DATABASE = HOST.database({
-        database: data.database,
-        credentials: {
-            method: "filemaker",
-            username: data.username,
-            password: data.password
-        },
-        externalSources: []
-    });
-    await DATABASE.login();
-    // Create file write stream
-    const stream = fs.createWriteStream("./types.ts");
-    let layouts = await DATABASE.listLayouts();
-    stream.write(`import FMHost, {Container, FieldBase, LayoutInterface, Portal} from "@jd-data-limited/easy-fm";\n`);
-    stream.write("// " + layouts.length + " layouts found\n\n");
-    let layoutInterfaces = new Map();
-    for (let layout of layouts) {
-        let substituteName = sub(layout.name);
-        if (!substituteName)
-            continue;
-        console.log(substituteName);
-        let metadata = await layout.getLayoutMeta();
-        let fields = processFieldsChunk(metadata.fieldMetaData);
-        let portals = metadata.portalMetaData;
-        let portalsProcessed = Object.keys(portals).map(portalName => {
-            return `${JSON.stringify(portalName)}: Portal<{${processFieldsChunk(portals[portalName])}}>`;
-        });
-        let interfaceName = substituteName + "LayoutInterface";
-        layoutInterfaces.set(layout.name, {
-            interfaceName,
-            interface: `export interface ${interfaceName} extends LayoutInterface {
-            fields: {${fields.join(",\n    ")}},
-            portals: {${portalsProcessed.join(",\n   ")}}
-        }`
         });
-    }
-    let layoutInterfaceLinks = [];
-    for (let layout of layoutInterfaces) {
-        layoutInterfaceLinks.push([
-            `${JSON.stringify(layout[0])}: ${layout[1].interfaceName}`,
-            `${sub(camelToSnakeCase(layout[0]).toUpperCase().replace(" ", "_"))}: HOST.getLayout<${layout[1].interfaceName}>(${JSON.stringify(layout[0])})`
-        ]);
-    }
-    stream.write(safeStringInjection `const HOST = new FMHost(${data.hostname}, ${data.timezoneOffset}, ${data.verify});`);
-    stream.write(`HOST.database<{layouts:{${layoutInterfaceLinks.map(i => i[0]).join(",")}}}>();`);
-    stream.write("\n\n");
-    stream.write(`const LAYOUTS = {${layoutInterfaceLinks.map(i => i[1]).join(",")}};`);
-    for (let layout of layoutInterfaces) {
-        stream.write("\n\n");
-        stream.write(layout[1].interface + ";");
-    }
-    // StructureKind
-    //
-    // const project = new Project({
-    //     tsConfigFilePath: "../tsconfig.json"
-    // })
-    // project.resolveSourceFileDependencies()
-    await DATABASE.logout();
-    console.log("DONE! Wrote database types to ./types.ts");
+    });
 }
+exports.generateTypesCLI = generateTypesCLI;
+var templateObject_1;

package/src/connection/FMHost.d.ts

@@ -11,6 +11,7 @@ export default class FMHost implements HostBase {
     readonly hostname: string;
     readonly timezoneOffsetFunc: (moment: Moment) => number;
     readonly verify: boolean;
+    readonly protocol: 'http:' | 'https:';
     _metadata: FMHostMetadata | null;
     constructor(_hostname: string, timezoneOffset?: (moment: Moment) => number, verify?: boolean);
     get metadata(): FMHostMetadata;

package/src/connection/FMHost.js

@@ -12,11 +12,13 @@ export default class FMHost {
     hostname;
     timezoneOffsetFunc;
     verify;
+    protocol;
     _metadata = null;
     constructor(_hostname, timezoneOffset = (moment) => 0 - (new Date()).getTimezoneOffset(), verify = true) {
         if (!(/^https?:\/\//).test(_hostname))
             throw new Error('hostname MUST begin with either http:// or https://');
-        this.hostname = _hostname;
+        this.protocol = _hostname.startsWith('https:') ? 'https:' : 'http:';
+        this.hostname = _hostname.split('//')[1];
         this.timezoneOffsetFunc = timezoneOffset;
         this.verify = verify;
     }
@@ -81,7 +83,7 @@ export default class FMHost {
     async getMetadata() {
         if (this._metadata)
             return this._metadata;
-        const _fetch = await fetch(`${this.hostname}/fmi/data/v2/productInfo`, {
+        const _fetch = await fetch(`${this.protocol}//${this.hostname}/fmi/data/v2/productInfo`, {
             method: 'GET'
         });
         const data = await _fetch.json();

package/src/connection/FMHost.ts

@@ -25,6 +25,7 @@ export default class FMHost implements HostBase {
     readonly hostname: string
     readonly timezoneOffsetFunc: (moment: Moment) => number
     readonly verify: boolean
+    readonly protocol: 'http:' | 'https:'
     _metadata: FMHostMetadata | null = null
 
     constructor (
@@ -33,7 +34,8 @@ export default class FMHost implements HostBase {
         verify = true
     ) {
         if (!(/^https?:\/\//).test(_hostname)) throw new Error('hostname MUST begin with either http:// or https://')
-        this.hostname = _hostname
+        this.protocol = _hostname.startsWith('https:') ? 'https:' : 'http:'
+        this.hostname = _hostname.split('//')[1]
         this.timezoneOffsetFunc = timezoneOffset
         this.verify = verify
     }
@@ -105,7 +107,7 @@ export default class FMHost implements HostBase {
     async getMetadata () {
         if (this._metadata) return this._metadata
 
-        const _fetch = await fetch(`${this.hostname}/fmi/data/v2/productInfo`, {
+        const _fetch = await fetch(`${this.protocol}//${this.hostname}/fmi/data/v2/productInfo`, {
             method: 'GET'
         })
         const data = await _fetch.json() as ApiResults<FMHostMetadata>

package/src/connection/HostBase.d.ts

@@ -2,6 +2,7 @@ import { type FMHostMetadata } from '../types.js';
 import { type Moment } from 'moment';
 export interface HostBase {
     readonly hostname: string;
+    readonly protocol: string;
     readonly timezoneOffsetFunc: (moment: Moment) => number;
     readonly verify: boolean;
     metadata: FMHostMetadata;

package/src/connection/HostBase.ts

@@ -7,6 +7,7 @@ import {type Moment} from 'moment'
 
 export interface HostBase {
     readonly hostname: string
+    readonly protocol: string
     readonly timezoneOffsetFunc: (moment: Moment) => number
     readonly verify: boolean
     metadata: FMHostMetadata

package/src/connection/database.d.ts

@@ -48,8 +48,8 @@ export declare class Database<T extends DatabaseStructure> extends EventEmitter
     _apiRequestRaw(url: URL | RequestInfo, options?: RequestInit & {
         headers?: Record<string, string>;
         useCookieJar?: boolean;
+        retries?: number;
     }, autoRelogin?: boolean): Promise<Response>;
-    private _generateCookieHeader;
     _apiRequestJSON<T = any>(url: URL | RequestInfo, options?: RequestInit & {
         headers?: Record<string, string>;
     }): Promise<ApiResults<T>>;

package/src/connection/database.js

@@ -6,7 +6,7 @@ import { generateAuthorizationHeaders } from './generateAuthorizationHeaders.js'
 import { FMError } from '../FMError.js';
 import { Layout } from '../layouts/layout.js';
 import fetch from 'node-fetch';
-// @ts-expect-error
+// @ts-expect-error - fetchWithCookies does not have available typescript types
 import fetchWithCookies, { CookieJar } from 'node-fetch-cookies';
 /**
  * Represents a database connection.
@@ -109,16 +109,25 @@ export class Database extends EventEmitter {
      * @returns {string} The endpoint URL.
      */
     get endpoint() {
-        return `${this.host.hostname}/fmi/data/v2/databases/${this.name}`;
+        return `${this.host.protocol}//${this.host.hostname}/fmi/data/v2/databases/${this.name}`;
     }
     async _apiRequestRaw(url, options = {}, autoRelogin = true) {
-        if (this.debug)
-            console.log(`EASYFM DEBUG: ${JSON.stringify(options)} ${url instanceof Request ? url.url : url}`);
-        if (this.token === '')
+        if (this.debug) {
+            console.log(`EASYFM DEBUG: ${JSON.stringify(options)} ${url instanceof URL
+                ? url.toString()
+                : typeof url === 'string' ? url : url.url}`);
+        }
+        const reqIsToDBHost = (url instanceof URL
+            ? url
+            : typeof url === 'string'
+                ? new URL(url)
+                : new URL(url.url)).hostname === this.host.hostname;
+        if (reqIsToDBHost && this.token === '')
             await this.login(true);
         if (!options.headers)
             options.headers = {};
-        options.headers.authorization = 'Bearer ' + this._token;
+        if (reqIsToDBHost)
+            options.headers.authorization = 'Bearer ' + this._token;
         // options.redirect = "manual"
         // options.headers.cookies = this._generateCookieHeader()
         // console.log(options.headers.cookies)
@@ -137,21 +146,21 @@ export class Database extends EventEmitter {
         // console.log(this.cookies, _fetch.status)
         // // console.log(this, this.cookies, url)
         // console.trace()
-        if (_fetch.status === 401 && autoRelogin) {
-            console.trace();
+        if (!_fetch.ok && (!options.retries || options.retries > 0)) {
+            if (this.debug) {
+                console.log(`EASYFM DEBUG: RE-ATTEMPTING REQUEST (${_fetch.status}) ${url instanceof URL
+                    ? url.toString()
+                    : typeof url === 'string' ? url : url.url}`);
+            }
+            return await this._apiRequestRaw(url, { ...options, retries: (options?.retries ?? 1) - 1 });
+        }
+        else if (_fetch.status === 401 && reqIsToDBHost && autoRelogin) {
             await this.login(true);
             return await this._apiRequestRaw(url, options, false);
         }
         else
             return _fetch;
     }
-    _generateCookieHeader() {
-        const out = [];
-        for (const key of Object.keys(this.cookies)) {
-            out.push(`${key}=${this.cookies[key]}`);
-        }
-        return out.join('; ');
-    }
     async _apiRequestJSON(url, options = {}) {
         if (!options.headers)
             options.headers = {};

package/src/connection/database.ts

@@ -13,7 +13,7 @@ import {type DatabaseBase} from './databaseBase.js'
 import {type ApiLayout, type ApiResults} from '../models/apiResults.js'
 import {type DatabaseStructure} from '../databaseStructure.js'
 import fetch, {type HeadersInit, type RequestInfo, type RequestInit, type Response} from 'node-fetch'
-// @ts-expect-error
+// @ts-expect-error - fetchWithCookies does not have available typescript types
 import fetchWithCookies, {CookieJar} from 'node-fetch-cookies'
 
 /**
@@ -45,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')
         }
     }
@@ -89,7 +90,8 @@ export class Database<T extends DatabaseStructure> extends EventEmitter implemen
         if (this.connection_details.credentials.method === 'token') {
             this._token = (this.connection_details.credentials).token
             return this.token
-        } else {
+        }
+        else {
             const url = new URL(`${this.endpoint}/sessions`)
             url.hostname = this.host.hostname
             const res = await fetch(url, {
@@ -106,7 +108,8 @@ export class Database<T extends DatabaseStructure> extends EventEmitter implemen
             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,
@@ -126,18 +129,34 @@ export class Database<T extends DatabaseStructure> extends EventEmitter implemen
      * @returns {string} The endpoint URL.
      */
     get endpoint (): string {
-        return `${this.host.hostname}/fmi/data/v2/databases/${this.name}`
+        return `${this.host.protocol}//${this.host.hostname}/fmi/data/v2/databases/${this.name}`
     }
 
     async _apiRequestRaw (url: URL | RequestInfo, options: RequestInit & {
         headers?: Record<string, string>
         useCookieJar?: boolean
+        retries?: number
     } = {}, 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 (this.debug) {
+            console.log(
+                `EASYFM DEBUG: ${JSON.stringify(options)} ${
+                    url instanceof URL
+                        ? url.toString()
+                        : typeof url === 'string' ? url : url.url
+                }`
+            )
+        }
+        const reqIsToDBHost = (
+            url instanceof URL
+                ? url
+                : typeof url === 'string'
+                    ? new URL(url)
+                    : new URL(url.url)
+        ).hostname === this.host.hostname
+        if (reqIsToDBHost && this.token === '') await this.login(true)
 
         if (!options.headers) options.headers = {}
-        options.headers.authorization = 'Bearer ' + this._token
+        if (reqIsToDBHost) options.headers.authorization = 'Bearer ' + this._token
         // options.redirect = "manual"
         // options.headers.cookies = this._generateCookieHeader()
         // console.log(options.headers.cookies)
@@ -158,19 +177,21 @@ export class Database<T extends DatabaseStructure> extends EventEmitter implemen
         // console.log(this.cookies, _fetch.status)
         // // console.log(this, this.cookies, url)
         // console.trace()
-        if (_fetch.status === 401 && autoRelogin) {
-            console.trace()
+        if (!_fetch.ok && (!options.retries || options.retries > 0)) {
+            if (this.debug) {
+                console.log(`EASYFM DEBUG: RE-ATTEMPTING REQUEST (${_fetch.status}) ${
+                    url instanceof URL
+                        ? url.toString()
+                        : typeof url === 'string' ? url : url.url
+                }`)
+            }
+            return await this._apiRequestRaw(url, {...options, retries: (options?.retries ?? 1) - 1})
+        }
+        else if (_fetch.status === 401 && reqIsToDBHost && autoRelogin) {
             await this.login(true)
             return await this._apiRequestRaw(url, options, false)
-        } else return _fetch
-    }
-
-    private _generateCookieHeader () {
-        const out: string[] = []
-        for (const key of Object.keys(this.cookies)) {
-            out.push(`${key}=${this.cookies[key]}`)
         }
-        return out.join('; ')
+        else return _fetch
     }
 
     async _apiRequestJSON<T = any>(url: URL | RequestInfo, options: RequestInit & {

package/src/connection/requestHoldable.d.ts

@@ -0,0 +1,10 @@
+import { type RequestInfo, type RequestInit, Response } from 'node-fetch';
+export declare class RequestHoldableClass {
+    #private;
+    protected cookies: any;
+    _addNewFuncToQueue(func: () => Promise<void>): void;
+    protected _holdableFetch(url: URL | RequestInfo, options: RequestInit & {
+        headers?: Record<string, string>;
+    }): Promise<Response>;
+}
+export declare function RequestHoldable<PROPS extends any[], R = any>(originalMethod: (...p: PROPS) => Promise<R>, context: ClassMethodDecoratorContext<RequestHoldableClass>): (this: RequestHoldableClass, ...args: PROPS) => Promise<R>;

package/src/connection/requestHoldable.js

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2024. See LICENSE file for more information
+ */
+// @ts-expect-error - NO types module for this
+import fetchWithCookies, { CookieJar } from 'node-fetch-cookies';
+export class RequestHoldableClass {
+    #functionQueue = [];
+    #requestsAreBeingHeld = false;
+    cookies = new CookieJar();
+    _addNewFuncToQueue(func) {
+        this.#functionQueue.push(func);
+        if (this.#functionQueue.length === 1)
+            void this.#executeQueue();
+    }
+    async _holdableFetch(url, options) {
+        url.
+            if(!this.#requestsAreBeingHeld);
+        {
+            // eslint-disable-next-line @typescript-eslint/return-await
+            return await fetchWithCookies(this.cookies, url, options);
+        }
+    }
+    async #executeQueue() {
+        while (this.#functionQueue.length !== 0) {
+            try {
+                await this.#functionQueue[0]();
+            }
+            catch (e) {
+                console.error(e);
+            }
+            this.#functionQueue.shift();
+        }
+    }
+}
+export function RequestHoldable(originalMethod, context) {
+    // eslint-disable-next-line @typescript-eslint/promise-function-async
+    function replacementMethod(...args) {
+        return new Promise((resolve, reject) => {
+            // eslint-disable-next-line @typescript-eslint/promise-function-async
+            this._addNewFuncToQueue(() => originalMethod.call(this, ...args).then(resolve).catch(reject));
+        });
+    }
+    return replacementMethod;
+}

package/src/records/field.d.ts

@@ -48,6 +48,12 @@ export declare class Field<T extends FieldValue> {
      * @returns {Promise<void>} - A promise that resolves when the file is successfully uploaded.
      */
     upload(file: File): Promise<void>;
-    stream(): Promise<NodeJS.ReadableStream>;
-    arrayBuffer(): Promise<ArrayBuffer>;
+    stream(): Promise<{
+        data: NodeJS.ReadableStream;
+        mime: string;
+    }>;
+    arrayBuffer(): Promise<{
+        data: ArrayBuffer;
+        mime: string;
+    }>;
 }

package/src/records/field.js

@@ -62,7 +62,7 @@ let Field = (() => {
                     if (!req.ok || !req.body) {
                         throw new Error(`HTTP Error: ${req.status} (${req.statusText})`);
                     }
-                    return req.body;
+                    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 });
@@ -204,7 +204,7 @@ let Field = (() => {
             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 await req.arrayBuffer();
+            return { data: await req.arrayBuffer(), mime: req.headers.get("Content-Type") ?? '' };
         }
     };
 })();

package/src/records/field.ts

@@ -160,12 +160,12 @@ export class Field<T extends FieldValue> {
     }
 
     @containerDownloadFunction
-    async #streamAsync () {
+    async #streamAsync (): Promise<{data: NodeJS.ReadableStream, mime: string}> {
         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.body
+        return {data: req.body, mime: req.headers.get("Content-Type") ?? ''}
     }
 
     async stream () {
@@ -173,10 +173,10 @@ export class Field<T extends FieldValue> {
     }
 
     @containerDownloadFunction
-    async arrayBuffer () {
+    async arrayBuffer (): Promise<{data: ArrayBuffer, mime: 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})`)
-        return await req.arrayBuffer()
+        return {data: await req.arrayBuffer(), mime: req.headers.get("Content-Type") ?? ''}
     }
 }
 

package/src/records/layoutRecord.js

@@ -50,6 +50,7 @@ export class LayoutRecord extends RecordBase {
                 method: 'POST',
                 body: JSON.stringify(data)
             });
+            console.log(res);
             if (!res.response) {
                 throw new FMError(res.messages[0].code, res.httpStatus, res);
             }

package/src/records/layoutRecord.ts

@@ -70,6 +70,7 @@ export class LayoutRecord<LAYOUT extends LayoutInterface> extends RecordBase<LAY
                 method: 'POST',
                 body: JSON.stringify(data)
             })
+            console.log(res)
 
             if (!res.response) {
                 throw new FMError(res.messages[0].code, res.httpStatus, res)