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

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,6 +29,8 @@ export class Field<T extends FieldValue> {
     protected _value: T | null
     edited: boolean
 
+    static firstContainerDownload: Promise<any> | null = null
+
     constructor (record: Parentable, id: string, contents: T) {
         this.parent = record
         this.id = id
@@ -125,64 +127,109 @@ 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)
 
         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) {
+            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 {
+            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 () {
+        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
+    }
 
-        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)
+    async stream () {
+        return await this.#streamAsync()
+    }
+
+    @containerDownloadFunction
+    async arrayBuffer () {
+        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()
+    }
+}
+
+function containerDownloadFunction<PROPS extends any[], T extends FieldValue, R = unknown> (originalMethod: (...p: PROPS) => Promise<R>, context: ClassMethodDecoratorContext<Field<T>>) {
+    async function replacementMethod (this: Field<T>, ...args: PROPS) {
+        return await ContainerDownloadExecutor.processTask(async () => await originalMethod.call(this, ...args))
+    }
+
+    return replacementMethod
+}
+
+class ContainerDownloadExecutorClass {
+    hasDownloadedFirstContainer: 0 | 1 | 2 = 0
+    waitingFuncs: Array<{
+        func: (() => any)
+        done: ((...args: any[]) => any)
+        err: ((e: any) => any)
+    }> = []
+
+    async processTask<T extends () => Promise<any>>(task: T) {
+        const isFirstTask = this.hasDownloadedFirstContainer === 0
+        if (isFirstTask) {
+            this.hasDownloadedFirstContainer = 1
+            let res
+            try {
+                res = await task()
+            } catch (e) {
+                this.hasDownloadedFirstContainer = 0
+                const 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 (const 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 await new Promise((resolve, reject) => {
+                this.waitingFuncs.push({
+                    func: task,
+                    done: resolve,
+                    err: reject
+                })
             })
-        })
+        } else return await task()
     }
 }
+
+const ContainerDownloadExecutor = new ContainerDownloadExecutorClass()

package/src/records/layoutRecord.js

@@ -153,7 +153,6 @@ export class LayoutRecord extends RecordBase {
         const res = await this.layout.database._apiRequestJSON(this.endpoint, {
             method: 'DELETE'
         });
-        console.log(res);
         if (typeof res.response?.scriptError !== 'undefined' && res.response?.scriptError !== '0') {
             throw new FMError(res.response.scriptError, res.httpStatus, res);
         }

package/src/records/layoutRecord.ts

@@ -177,7 +177,6 @@ export class LayoutRecord<LAYOUT extends LayoutInterface> extends RecordBase<LAY
         const res = await this.layout.database._apiRequestJSON(this.endpoint, {
             method: 'DELETE'
         })
-        console.log(res)
         if (typeof res.response?.scriptError !== 'undefined' && res.response?.scriptError !== '0') {
             throw new FMError(res.response.scriptError, res.httpStatus, res)
         } else if (res.messages[0].code === '0') {

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