@jd-data-limited/easy-fm 3.2.3 → 3.2.5

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@jd-data-limited/easy-fm",
-  "version": "3.2.3",
+  "version": "3.2.5",
   "dependencies": {
     "@types/btoa": "^1.2.3",
     "@types/events": "^3.0.0",
+    "follow-redirects": "^1.15.3",
     "moment": "^2.29.4",
     "node-fetch": "3.2.8",
-    "node-fetch-cookies": "^2.1.0",
     "typescript": "^5.2.2",
     "ytdl-core": "^4.11.4"
   },

package/src/connection/database.d.ts

@@ -1,8 +1,9 @@
 /// <reference types="node" />
 import { EventEmitter } from "events";
-import { Request } from "node-fetch-cookies";
+import { Request } from "node-fetch";
 import { LayoutInterface } from "../layouts/layoutInterface.js";
 import { Layout } from "../layouts/layout.js";
+import redirecter from "follow-redirects";
 import { databaseOptionsWithExternalSources, DatabaseStructure, Script } from "../types.js";
 import { HostBase } from "./HostBase.js";
 import { DatabaseBase } from "./databaseBase";
@@ -10,7 +11,7 @@ export declare class Database<T extends DatabaseStructure> extends EventEmitter
     private _token;
     readonly host: HostBase;
     private connection_details;
-    private cookieJar;
+    private cookies;
     readonly name: string;
     constructor(host: HostBase, conn: databaseOptionsWithExternalSources);
     private generateExternalSourceLogin;
@@ -24,5 +25,5 @@ export declare class Database<T extends DatabaseStructure> extends EventEmitter
     setGlobals(globalFields: any): Promise<void>;
     script(name: any, parameter?: string): Script;
     _tokenExpired(): void;
-    streamContainer(url: any): Promise<any>;
+    streamContainer(field: any, url: any): Promise<redirecter.http.IncomingMessage>;
 }

package/src/connection/database.js

@@ -11,14 +11,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { EventEmitter } from "events";
-import { fetch, CookieJar } from "node-fetch-cookies";
+import fetch from "node-fetch";
 import { generateAuthorizationHeaders } from "./generateAuthorizationHeaders.js";
 import { FMError } from "../FMError.js";
 import { Layout } from "../layouts/layout.js";
+import redirecter from "follow-redirects";
 export class Database extends EventEmitter {
     constructor(host, conn) {
         super();
-        this.cookieJar = new CookieJar();
+        this.cookies = {};
         this.host = host;
         this.name = conn.database;
         this.connection_details = conn;
@@ -40,7 +41,7 @@ export class Database extends EventEmitter {
         return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
             if (!this.token)
                 reject(new Error("Not logged in"));
-            let _fetch = yield fetch(this.cookieJar, `${this.endpoint}/sessions/${this.token}`, {
+            let _fetch = yield fetch(`${this.endpoint}/sessions/${this.token}`, {
                 method: "DELETE",
                 headers: {
                     "content-type": "application/json"
@@ -55,7 +56,7 @@ export class Database extends EventEmitter {
     login() {
         return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
             // Reset cookies
-            this.cookieJar = {};
+            this.cookies = {};
             try {
                 yield this.host.getMetadata();
             }
@@ -70,7 +71,7 @@ export class Database extends EventEmitter {
                 resolve(this.token);
             }
             else {
-                fetch(this.cookieJar, `${this.endpoint}/sessions`, {
+                fetch(`${this.endpoint}/sessions`, {
                     hostname: this.host.hostname,
                     port: 443,
                     method: "POST",
@@ -110,11 +111,11 @@ export class Database extends EventEmitter {
             options.headers["content-type"] = options.headers["content-type"] ? options.headers["content-type"] : "application/json";
             options.headers["authorization"] = "Bearer " + this._token;
             options.rejectUnauthorized = this.host.verify;
-            let _fetch = yield fetch(this.cookieJar, url, options);
+            let _fetch = yield fetch(url, options);
             if (_fetch.headers.get('set-cookie')) {
                 for (let cookie of _fetch.headers.get('set-cookie')) {
                     let cookie_split = cookie.split("=");
-                    this.cookieJar[cookie_split[0]] = cookie_split[1];
+                    this.cookies[cookie_split[0]] = cookie_split[1];
                 }
             }
             let data = yield _fetch.json();
@@ -156,28 +157,38 @@ export class Database extends EventEmitter {
     _tokenExpired() {
         this.emit("token_expired");
     }
-    streamContainer(url) {
-        return __awaiter(this, void 0, void 0, function* () {
+    streamContainer(field, url) {
+        return new Promise((resolve, reject) => {
+            if (field.metadata.result !== "container") {
+                reject("Cannot stream the field " + field.id + " as it is not a container");
+                return;
+            }
+            if (!url || typeof url !== "string") {
+                reject("Container is empty, or has invalid value");
+                return;
+            }
             let headers = {};
-            if (Object.keys(this.cookieJar).length !== 0) {
-                headers["Cookie"] = Object.keys(this.cookieJar)
+            if (Object.keys(this.cookies).length !== 0) {
+                headers["Cookie"] = Object.keys(this.cookies)
                     .map(key => {
-                    return key + "=" + this.cookieJar[key];
+                    return key + "=" + this.cookies[key];
                 })
                     .join("; ");
             }
             // Automatically switch between the http and https modules, based on which is needed
-            let res = yield fetch(this.cookieJar, url, {
+            (url.startsWith("https") ? redirecter.https : redirecter.http).get(url, {
                 headers
-            });
-            if (res.headers.get('set-cookie')) {
-                for (let cookie of res.headers['set-cookie']) {
-                    let cookie_split = cookie.split("=");
-                    this.cookieJar[cookie_split[0]] = cookie_split[1];
+            }, (res) => {
+                // Check for the 'set-cookie' header. If it exists, remember it and strip it for better security.
+                if (res.headers['set-cookie']) {
+                    for (let cookie of res.headers['set-cookie']) {
+                        let cookie_split = cookie.split("=");
+                        this.cookies[cookie_split[0]] = cookie_split[1];
+                    }
+                    res.headers['set-cookie'] = null;
                 }
-                res.headers.set('set-cookie', null);
-            }
-            return res;
+                resolve(res);
+            });
         });
     }
 }

package/src/connection/database.ts

@@ -3,14 +3,12 @@
  */
 
 import {EventEmitter} from "events";
-import {HeadersInit} from "node-fetch";
-import {fetch, CookieJar, Request} from "node-fetch-cookies"
+import fetch, {HeadersInit, Request} from "node-fetch";
 import {generateAuthorizationHeaders} from "./generateAuthorizationHeaders.js";
 import {FMError} from "../FMError.js";
 import {LayoutInterface} from "../layouts/layoutInterface.js";
 import {Layout} from "../layouts/layout.js";
-import * as http from "http";
-import * as https from "https";
+import redirecter from "follow-redirects"
 import {
     databaseOptionsBase,
     databaseOptionsWithExternalSources, DatabaseStructure,
@@ -28,7 +26,7 @@ export class Database<T extends DatabaseStructure> extends EventEmitter implemen
     private _token: any;
     readonly host: HostBase;
     private connection_details: databaseOptionsWithExternalSources
-    private cookieJar = new CookieJar()
+    private cookies: { [key: string]: string } = {}
     readonly name: string;
 
     constructor(host: HostBase, conn: databaseOptionsWithExternalSources) {
@@ -56,7 +54,7 @@ export class Database<T extends DatabaseStructure> extends EventEmitter implemen
         return new Promise(async (resolve, reject) => {
             if (!this.token) reject(new Error("Not logged in"))
 
-            let _fetch = await fetch(this.cookieJar, `${this.endpoint}/sessions/${this.token}`, {
+            let _fetch = await fetch(`${this.endpoint}/sessions/${this.token}`, {
                 method: "DELETE",
                 headers: {
                     "content-type": "application/json"
@@ -72,7 +70,7 @@ export class Database<T extends DatabaseStructure> extends EventEmitter implemen
     login() {
         return new Promise<string>(async (resolve, reject) => {
             // Reset cookies
-            this.cookieJar = {}
+            this.cookies = {}
 
             try {
                 await this.host.getMetadata()
@@ -87,7 +85,7 @@ export class Database<T extends DatabaseStructure> extends EventEmitter implemen
                 resolve(this.token)
             }
             else {
-                fetch(this.cookieJar, `${this.endpoint}/sessions`, {
+                fetch(`${this.endpoint}/sessions`, {
                     hostname: this.host.hostname,
                     port: 443,
                     method: "POST",
@@ -129,11 +127,11 @@ export class Database<T extends DatabaseStructure> extends EventEmitter implemen
         options.headers["authorization"] = "Bearer " + this._token
         options.rejectUnauthorized = this.host.verify
 
-        let _fetch = await fetch(this.cookieJar, url, options)
+        let _fetch = await fetch(url, options)
         if (_fetch.headers.get('set-cookie')) {
             for (let cookie of _fetch.headers.get('set-cookie')) {
                 let cookie_split = cookie.split("=")
-                this.cookieJar[cookie_split[0]] = cookie_split[1]
+                this.cookies[cookie_split[0]] = cookie_split[1]
             }
         }
         let data = await _fetch.json() as fileMakerResponse
@@ -182,31 +180,41 @@ export class Database<T extends DatabaseStructure> extends EventEmitter implemen
         this.emit("token_expired")
     }
 
-    async streamContainer(url) {
+    streamContainer(field, url): Promise<redirecter.http.IncomingMessage> {
+        return new Promise((resolve, reject) => {
+            if (field.metadata.result !== "container") {
+                reject("Cannot stream the field " + field.id + " as it is not a container")
+                return
+            }
+            if (!url || typeof url !== "string") {
+                reject("Container is empty, or has invalid value")
+                return
+            }
 
+            let headers = {}
+            if (Object.keys(this.cookies).length !== 0) {
+                headers["Cookie"] = Object.keys(this.cookies)
+                    .map(key => {
+                        return key + "=" + this.cookies[key]
+                    })
+                    .join("; ")
+            }
 
-        let headers = {}
-        if (Object.keys(this.cookieJar).length !== 0) {
-            headers["Cookie"] = Object.keys(this.cookieJar)
-                .map(key => {
-                    return key + "=" + this.cookieJar[key]
-                })
-                .join("; ")
-        }
+            // Automatically switch between the http and https modules, based on which is needed
+            (url.startsWith("https") ? redirecter.https : redirecter.http).get(url, {
+                headers
+            }, (res) => {
+                // Check for the 'set-cookie' header. If it exists, remember it and strip it for better security.
+                if (res.headers['set-cookie']) {
+                    for (let cookie of res.headers['set-cookie']) {
+                        let cookie_split = cookie.split("=")
+                        this.cookies[cookie_split[0]] = cookie_split[1]
+                    }
+                    res.headers['set-cookie'] = null
+                }
 
-        // Automatically switch between the http and https modules, based on which is needed
-        let res = await fetch(this.cookieJar, url, {
-            headers
+                resolve(res)
+            })
         })
-
-        if (res.headers.get('set-cookie')) {
-            for (let cookie of res.headers['set-cookie']) {
-                let cookie_split = cookie.split("=")
-                this.cookieJar[cookie_split[0]] = cookie_split[1]
-            }
-            res.headers.set('set-cookie', null)
-        }
-        return res
     }
-
 }

package/src/connection/databaseBase.d.ts

@@ -1,10 +1,8 @@
 import { HostBase } from "./HostBase.js";
 import { Request } from "node-fetch";
-import { Response } from "node-fetch";
 export interface DatabaseBase {
     host: HostBase;
     readonly name: string;
     endpoint: string;
     apiRequest(url: string | Request, options?: any, autoRelogin?: boolean): Promise<any>;
-    streamContainer(url: string): Promise<Response>;
 }

package/src/connection/databaseBase.ts

@@ -5,7 +5,6 @@
 import {HostBase} from "./HostBase.js"
 import {Request} from "node-fetch";
 import {DatabaseStructure} from "../types";
-import {Response} from "node-fetch";
 
 export interface DatabaseBase {
     host: HostBase,
@@ -15,5 +14,4 @@ export interface DatabaseBase {
     // layouts: DatabaseStructure["layouts"]
 
     apiRequest(url: string | Request, options?: any, autoRelogin?: boolean): Promise<any>
-    streamContainer(url: string): Promise<Response>
 }

package/src/records/field.d.ts

@@ -1,7 +1,8 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import { RecordBase } from "./recordBase.js";
-import { ContainerDataStream, DOWNLOAD_MODES, FieldMetaData } from "../types.js";
+import * as http from "http";
+import { ContainerBufferResult, DOWNLOAD_MODES, FieldMetaData } from "../types.js";
 export type FieldValue = string | number | Date | Container;
 export type Container = null;
 export declare class Field<T extends FieldValue> {
@@ -18,6 +19,6 @@ export declare class Field<T extends FieldValue> {
     get date(): Date;
     get number(): number;
     upload(buffer: Buffer, filename: string, mime: string): Promise<void>;
-    download(mode: DOWNLOAD_MODES.Stream): Promise<ContainerDataStream<NodeJS.ReadableStream>>;
-    download(mode: DOWNLOAD_MODES.Buffer): Promise<ContainerDataStream<ArrayBuffer>>;
+    download(mode: DOWNLOAD_MODES.Stream): Promise<http.IncomingMessage>;
+    download(mode: DOWNLOAD_MODES.Buffer): Promise<ContainerBufferResult>;
 }

package/src/records/field.js

@@ -149,27 +149,32 @@ export class Field {
         }));
     }
     download(mode = DOWNLOAD_MODES.Stream) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.metadata.result !== "container") {
-                throw new Error("Cannot stream the field " + this.id + " as it is not a container");
-            }
-            if (!this.value || typeof this.value !== "string") {
-                throw new Error("Container is empty, or has invalid value");
-            }
-            let res = yield this.record.layout.database.streamContainer(this.string);
-            let data;
-            switch (mode) {
-                case DOWNLOAD_MODES.Buffer:
-                    data = yield res.arrayBuffer();
-                    break;
-                case DOWNLOAD_MODES.Stream:
-                    data = res.body;
-                    break;
-            }
-            return {
-                data,
-                mime: res.headers.get("content-type")
-            };
+        return new Promise((resolve, reject) => {
+            // @ts-ignore
+            this.record.layout.database.streamContainer(this, this._value)
+                .then(stream => {
+                if (mode === DOWNLOAD_MODES.Stream) {
+                    resolve(stream);
+                    return;
+                }
+                let body = [];
+                stream.on("data", chunk => {
+                    body.push(chunk);
+                });
+                stream.on("error", (e) => {
+                    reject(e);
+                });
+                stream.on("end", () => {
+                    resolve({
+                        buffer: Buffer.concat(body),
+                        mime: stream.headers["content-type"],
+                        request: stream
+                    });
+                });
+            })
+                .catch(e => {
+                reject(e);
+            });
         });
     }
 }

package/src/records/field.ts

@@ -5,7 +5,7 @@
 import {RecordBase, RecordTypes} from "./recordBase.js";
 import fetch, {File, FormData} from "node-fetch";
 import * as http from "http";
-import {ContainerDataStream, DOWNLOAD_MODES, FieldMetaData} from "../types.js";
+import {ContainerBufferResult, DOWNLOAD_MODES, FieldMetaData} from "../types.js";
 import {FMError} from "../FMError.js";
 
 export type FieldValue = string | number | Date | Container
@@ -158,26 +158,36 @@ export class Field<T extends FieldValue> {
         })
     }
 
-    download(mode: DOWNLOAD_MODES.Stream): Promise<ContainerDataStream<NodeJS.ReadableStream>>
-    download(mode: DOWNLOAD_MODES.Buffer): Promise<ContainerDataStream<ArrayBuffer>>
-    async download(mode: DOWNLOAD_MODES = DOWNLOAD_MODES.Stream): Promise<ContainerDataStream> {
-        if (this.metadata.result !== "container") {
-            throw new Error("Cannot stream the field " + this.id + " as it is not a container")
-        }
-        if (!this.value || typeof this.value !== "string") {
-            throw new Error("Container is empty, or has invalid value")
-        }
-
-        let res = await this.record.layout.database.streamContainer(this.string)
-        let data: NodeJS.ReadableStream | ArrayBuffer
-        switch (mode) {
-            case DOWNLOAD_MODES.Buffer: data = await res.arrayBuffer(); break
-            case DOWNLOAD_MODES.Stream: data = res.body; break
-        }
+    download(mode: DOWNLOAD_MODES.Stream): Promise<http.IncomingMessage>
+    download(mode: DOWNLOAD_MODES.Buffer): Promise<ContainerBufferResult>
+    download(mode: DOWNLOAD_MODES = DOWNLOAD_MODES.Stream): Promise<http.IncomingMessage | ContainerBufferResult> {
+        return new Promise((resolve, reject) => {
+            // @ts-ignore
+            this.record.layout.database.streamContainer(this, this._value)
+                .then(stream => {
+                    if (mode === DOWNLOAD_MODES.Stream) {
+                        resolve(stream)
+                        return
+                    }
 
-        return {
-            data,
-            mime: res.headers.get("content-type")
-        }
+                    let body = []
+                    stream.on("data", chunk => {
+                        body.push(chunk)
+                    })
+                    stream.on("error", (e) => {
+                        reject(e)
+                    })
+                    stream.on("end", () => {
+                        resolve({
+                            buffer: Buffer.concat(body),
+                            mime: stream.headers["content-type"],
+                            request: stream
+                        } as ContainerBufferResult)
+                    })
+                })
+                .catch(e => {
+                    reject(e)
+                })
+        })
     }
 }

package/src/types.d.ts

@@ -1,4 +1,6 @@
 /// <reference types="node" />
+/// <reference types="node" />
+import * as http from "http";
 import { FMError } from "./FMError.js";
 import { LayoutInterface } from "./layouts/layoutInterface";
 export interface DatabaseStructure {
@@ -106,9 +108,10 @@ export interface ScriptResult {
     scriptError?: FMError;
     scriptResult?: string;
 }
-export interface ContainerDataStream<T = NodeJS.ReadableStream | ArrayBuffer> {
-    data: T;
+export interface ContainerBufferResult {
+    buffer: Buffer;
     mime: string;
+    request: http.IncomingMessage;
 }
 export interface AuthorizationHeaders {
     "Content-Type": "application/json";

package/src/types.ts

@@ -132,9 +132,10 @@ export interface ScriptResult {
     scriptResult?: string
 }
 
-export interface ContainerDataStream<T = NodeJS.ReadableStream | ArrayBuffer> {
-    data: T,
-    mime: string
+export interface ContainerBufferResult {
+    buffer: Buffer,
+    mime: string,
+    request: http.IncomingMessage
 }
 
 //