@jd-data-limited/easy-fm 3.2.2 → 3.2.4

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@jd-data-limited/easy-fm",
-  "version": "3.2.2",
+  "version": "3.2.4",
   "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",
     "typescript": "^5.2.2",

package/src/connection/database.d.ts

@@ -3,6 +3,7 @@ import { EventEmitter } from "events";
 import { Request } from "node-fetch";
 import { LayoutInterface } from "../layouts/layoutInterface.js";
 import { Layout } from "../layouts/layout.js";
+import { http } from "follow-redirects";
 import { databaseOptionsWithExternalSources, DatabaseStructure, Script } from "../types.js";
 import { HostBase } from "./HostBase.js";
 import { DatabaseBase } from "./databaseBase";
@@ -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<import("node-fetch").Response>;
+    streamContainer(field: any, url: any): Promise<http.IncomingMessage>;
 }

package/src/connection/database.js

@@ -15,6 +15,7 @@ import fetch from "node-fetch";
 import { generateAuthorizationHeaders } from "./generateAuthorizationHeaders.js";
 import { FMError } from "../FMError.js";
 import { Layout } from "../layouts/layout.js";
+import { http, https } from "follow-redirects";
 export class Database extends EventEmitter {
     constructor(host, conn) {
         super();
@@ -156,8 +157,16 @@ 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.cookies).length !== 0) {
                 headers["Cookie"] = Object.keys(this.cookies)
@@ -167,17 +176,19 @@ export class Database extends EventEmitter {
                     .join("; ");
             }
             // Automatically switch between the http and https modules, based on which is needed
-            let res = yield fetch(url, {
+            (url.startsWith("https") ? https : http).get(url, {
                 headers
-            });
-            if (res.headers.get('set-cookie')) {
-                for (let cookie of res.headers['set-cookie']) {
-                    let cookie_split = cookie.split("=");
-                    this.cookies[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

@@ -8,8 +8,7 @@ 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 {http, https} from "follow-redirects"
 import {
     databaseOptionsBase,
     databaseOptionsWithExternalSources, DatabaseStructure,
@@ -181,31 +180,41 @@ export class Database<T extends DatabaseStructure> extends EventEmitter implemen
         this.emit("token_expired")
     }
 
-    async streamContainer(url) {
+    streamContainer(field, url): Promise<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.cookies).length !== 0) {
-            headers["Cookie"] = Object.keys(this.cookies)
-                .map(key => {
-                    return key + "=" + this.cookies[key]
-                })
-                .join("; ")
-        }
+            // Automatically switch between the http and https modules, based on which is needed
+            (url.startsWith("https") ? https : 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(url, {
-            headers
+                resolve(res)
+            })
         })
-
-        if (res.headers.get('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('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
 }
 
 //