@jd-data-limited/easy-fm 3.2.6 → 3.2.8

package/src/connection/database.ts

@@ -12,13 +12,13 @@ import HTTP_REDIRECT  from "follow-redirects"
 import {
     databaseOptionsBase,
     databaseOptionsWithExternalSources, DatabaseStructure,
-    fileMakerResponse,
     loginOptionsFileMaker,
     loginOptionsToken,
     Script
 } from "../types.js";
 import {HostBase} from "./HostBase.js"
 import {DatabaseBase} from "./databaseBase";
+import {ApiLayout, ApiResults} from "../models/apiResults";
 
 type GetLayoutReturnType<T extends DatabaseStructure, R extends LayoutInterface | string> = R extends string ? T["layouts"][R] : R
 
@@ -50,67 +50,55 @@ export class Database<T extends DatabaseStructure> extends EventEmitter implemen
         }
     }
 
-    logout(): Promise<void> {
-        return new Promise(async (resolve, reject) => {
-            if (!this.token) reject(new Error("Not logged in"))
+    async logout(): Promise<void> {
+        if (!this.token) throw new Error("Not logged in")
 
-            let _fetch = await fetch(`${this.endpoint}/sessions/${this.token}`, {
-                method: "DELETE",
-                headers: {
-                    "content-type": "application/json"
-                }
-            })
-            let data = await _fetch.json()
-            // console.log(data)
-            this._token = null
-            resolve()
+        let _fetch = await fetch(`${this.endpoint}/sessions/${this.token}`, {
+            method: "DELETE",
+            headers: {
+                "content-type": "application/json"
+            }
         })
+        let data = await _fetch.json()
+        // console.log(data)
+        this._token = null
     }
 
-    login() {
-        return new Promise<string>(async (resolve, reject) => {
-            // Reset cookies
-            this.cookies = {}
+    async login() {
+        // Reset cookies
+        this.cookies = {}
 
-            try {
-                await this.host.getMetadata()
-            } catch (e) {
-                reject(e)
-                return
-            }
-            if (this.token) throw new Error("Already logged in. Run logout() first")
+        await this.host.getMetadata()
+        if (this.token) throw new Error("Already logged in. Run logout() first")
 
-            if (this.connection_details.credentials.method === "token") {
-                this._token = (<loginOptionsToken>this.connection_details.credentials).token
-                resolve(this.token)
-            }
-            else {
-                fetch(`${this.endpoint}/sessions`, {
-                    hostname: this.host.hostname,
-                    port: 443,
-                    method: "POST",
-                    headers: generateAuthorizationHeaders(this.connection_details.credentials) as unknown as HeadersInit,
-                    body: JSON.stringify({
-                        fmDataSource: this.connection_details.externalSources.map(i => {
-                            let _i = <databaseOptionsBase>i
-                            return this.generateExternalSourceLogin(_i)
-                        })
+        if (this.connection_details.credentials.method === "token") {
+            this._token = (<loginOptionsToken>this.connection_details.credentials).token
+            return this.token
+        }
+        else {
+            console.time()
+            let res = await fetch(`${this.endpoint}/sessions`, {
+                hostname: this.host.hostname,
+                port: 443,
+                method: "POST",
+                headers: generateAuthorizationHeaders(this.connection_details.credentials) as unknown as HeadersInit,
+                body: JSON.stringify({
+                    fmDataSource: this.connection_details.externalSources.map(i => {
+                        let _i = <databaseOptionsBase>i
+                        return this.generateExternalSourceLogin(_i)
                     })
-                }).then(async res => {
-                    let _res = <any>(await res.json())
-                    if (res.status === 200) {
-                        this._token = res.headers.get('x-fm-data-access-token')
-                        resolve(this._token)
-                    }
-                    else {
-                        reject(new FMError(_res.messages[0].code, _res.status, res))
-                    }
                 })
-                    .catch(e => {
-                        reject(e)
-                    })
+            })
+            console.time()
+            let _res = <any>(await res.json())
+            if (res.status === 200) {
+                this._token = res.headers.get('x-fm-data-access-token')
+                return this._token
             }
-        })
+            else {
+                throw new FMError(_res.messages[0].code, _res.status, res)
+            }
+        }
     }
 
     get token() {
@@ -121,7 +109,7 @@ export class Database<T extends DatabaseStructure> extends EventEmitter implemen
         return `${this.host.hostname}/fmi/data/v2/databases/${this.name}`
     }
 
-    async apiRequest<T = any>(url: string | Request, options: any = {}, autoRelogin = true): Promise<T> {
+    async apiRequest<T = any>(url: string | Request, options: any = {}, autoRelogin = true): Promise<ApiResults<T>> {
         if (!options.headers) options.headers = {}
         options.headers["content-type"] = options.headers["content-type"] ? options.headers["content-type"] : "application/json"
         options.headers["authorization"] = "Bearer " + this._token
@@ -134,14 +122,30 @@ export class Database<T extends DatabaseStructure> extends EventEmitter implemen
                 this.cookies[cookie_split[0]] = cookie_split[1]
             }
         }
-        let data = await _fetch.json() as fileMakerResponse
+        let data = await _fetch.json() as ApiResults<T>
+
+        // Remove response if it is empty. This makes checking for an empty response easier
+        if (Object.keys(data.response).length === 0) delete data.response
+
         // console.log(data.messages[0])
-        if (data.messages[0].code == 952 && autoRelogin) {
+        if (data.messages[0].code === "952" && autoRelogin) {
             this._token = null
             await this.login()
             return await this.apiRequest(url, options, false)
         }
-        return (data as any)
+        else if (data.messages[0].code !== "0") {
+            throw new FMError(data.messages[0].code, _fetch.status, data)
+        }
+
+        data.httpStatus = _fetch.status
+        return data
+    }
+
+    async listLayouts() {
+        let req = await this.apiRequest<{layouts: ApiLayout[]}>(`${this.endpoint}/layouts`)
+        if (!req.response) throw new FMError(req.messages[0].code, req.httpStatus, req.messages[0].message)
+
+        return req.response.layouts.filter(i => !i.isFolder).map(layout => new Layout(this, layout.name))
     }
 
     getLayout<R extends string>(name: R): Layout<T["layouts"][R]>
@@ -150,25 +154,14 @@ export class Database<T extends DatabaseStructure> extends EventEmitter implemen
         return new Layout<LayoutInterface>(this, name)
     }
 
-    setGlobals(globalFields): Promise<void> {
+    /*
+    @deprecated
+     */
+    async setGlobals(globalFields) {
         // console.log({globalFields})
-        return new Promise((resolve, reject) => {
-            this.apiRequest(`${this.endpoint}/globals`, {
-                method: "PATCH",
-                body: JSON.stringify({globalFields})
-            }).then(res => {
-                // console.log(res)
-                if (res.messages[0].code === "0") {
-                    resolve()
-                }
-                else {
-                    reject(
-                        (res.messages[0].code, res.status, res))
-                }
-            })
-                .catch(e => {
-                    reject(e)
-                })
+        await this.apiRequest(`${this.endpoint}/globals`, {
+            method: "PATCH",
+            body: JSON.stringify({globalFields})
         })
     }
 
@@ -180,15 +173,10 @@ export class Database<T extends DatabaseStructure> extends EventEmitter implemen
         this.emit("token_expired")
     }
 
-    streamContainer(field, url): Promise<HTTP_REDIRECT.http.IncomingMessage> {
+    streamURL(url: string): Promise<HTTP_REDIRECT.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
+                throw new Error("URL is empty, or has invalid value")
             }
 
             let headers = {}

package/src/connection/databaseBase.d.ts

@@ -1,8 +1,11 @@
 import { HostBase } from "./HostBase.js";
 import { Request } from "node-fetch";
+import { ApiResults } from "../models/apiResults";
+import HTTP_REDIRECT from "follow-redirects";
 export interface DatabaseBase {
     host: HostBase;
     readonly name: string;
     endpoint: string;
-    apiRequest(url: string | Request, options?: any, autoRelogin?: boolean): Promise<any>;
+    apiRequest<T = unknown>(url: string | Request, options?: any, autoRelogin?: boolean): Promise<ApiResults<T>>;
+    streamURL(url: string): Promise<HTTP_REDIRECT.http.IncomingMessage>;
 }

package/src/connection/databaseBase.ts

@@ -5,6 +5,8 @@
 import {HostBase} from "./HostBase.js"
 import {Request} from "node-fetch";
 import {DatabaseStructure} from "../types";
+import {ApiResults} from "../models/apiResults";
+import HTTP_REDIRECT  from "follow-redirects"
 
 export interface DatabaseBase {
     host: HostBase,
@@ -13,5 +15,6 @@ export interface DatabaseBase {
 
     // layouts: DatabaseStructure["layouts"]
 
-    apiRequest(url: string | Request, options?: any, autoRelogin?: boolean): Promise<any>
+    apiRequest<T = unknown>(url: string | Request, options?: any, autoRelogin?: boolean): Promise<ApiResults<T>>
+    streamURL(url: string): Promise<HTTP_REDIRECT.http.IncomingMessage>
 }

package/src/layouts/layout.d.ts

@@ -3,14 +3,14 @@ import { LayoutRecord } from "../records/layoutRecord.js";
 import { Script, ScriptResult } from "../types.js";
 import { LayoutInterface } from "./layoutInterface.js";
 import { Find } from "../records/getOperations/find.js";
-import { FMError } from "../FMError.js";
 import { LayoutBase } from "./layoutBase.js";
 import { DatabaseBase } from "../connection/databaseBase";
+import { ApiLayoutMetadata } from "../models/apiResults";
 export declare class Layout<T extends LayoutInterface> implements LayoutBase {
     readonly database: DatabaseBase;
     readonly records: LayoutRecordManager<T>;
     readonly name: string;
-    metadata: any;
+    metadata: ApiLayoutMetadata;
     constructor(database: DatabaseBase, name: string);
     get endpoint(): string;
     /**
@@ -26,5 +26,5 @@ export declare class Layout<T extends LayoutInterface> implements LayoutBase {
      */
     newFind(): Find<T>;
     runScript(script: Script): Promise<ScriptResult>;
-    getLayoutMeta(): Promise<this | FMError>;
+    getLayoutMeta(): Promise<ApiLayoutMetadata>;
 }

package/src/layouts/layout.js

@@ -1,20 +1,14 @@
 /*
  * Copyright (c) 2023. See LICENSE file for more information
  */
-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());
-    });
-};
 import { LayoutRecordManager } from "./layoutRecordManager.js";
 import { FMError } from "../FMError.js";
 export class Layout {
+    database;
+    records = new LayoutRecordManager(this);
+    name;
+    metadata;
     constructor(database, name) {
-        this.records = new LayoutRecordManager(this);
         this.database = database;
         this.name = name;
     }
@@ -39,46 +33,28 @@ export class Layout {
     newFind() {
         return this.records.find();
     }
-    runScript(script) {
-        let trace = new Error();
-        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-            let url = `${this.endpoint}/script/${encodeURIComponent(script.name)}`;
-            if (script.parameter)
-                url += "?script.param=" + encodeURIComponent(script.parameter);
-            this.database.apiRequest(url, {
-                port: 443,
-                method: "GET"
-            })
-                .then(res => {
-                if (res.messages[0].code === "0") {
-                    let error = parseInt(res.response.scriptError);
-                    let msg = {
-                        scriptError: error ? new FMError(error, 200, res, trace) : undefined,
-                        scriptResult: res.response.scriptResult
-                    };
-                    resolve(msg);
-                }
-                else {
-                    // console.log(res)
-                    reject(new FMError(res.messages[0].code, res.status, res, trace));
-                }
-            })
-                .catch(e => {
-                reject(e);
-            });
-        }));
-    }
-    getLayoutMeta() {
-        return new Promise((resolve, reject) => {
-            if (this.metadata) {
-                resolve(this.metadata);
-                return;
-            }
-            this.database.apiRequest(this.endpoint).then(res => {
-                this.metadata = res.response;
-                resolve(this);
-            })
-                .catch(e => reject(e));
+    async runScript(script) {
+        let url = `${this.endpoint}/script/${encodeURIComponent(script.name)}`;
+        if (script.parameter)
+            url += "?script.param=" + encodeURIComponent(script.parameter);
+        let res = await this.database.apiRequest(url, {
+            port: 443,
+            method: "GET"
         });
+        if (res.messages[0].code === "0") {
+            let error = parseInt(res.response.scriptError);
+            return {
+                scriptError: error ? new FMError(error, 200, res) : undefined,
+                scriptResult: res.response.scriptResult
+            };
+        }
+    }
+    async getLayoutMeta() {
+        if (this.metadata) {
+            return this.metadata;
+        }
+        let res = await this.database.apiRequest(this.endpoint);
+        this.metadata = res.response;
+        return this.metadata;
     }
 }

package/src/layouts/layout.ts

@@ -10,12 +10,13 @@ import {Find} from "../records/getOperations/find.js";
 import {FMError} from "../FMError.js";
 import {LayoutBase} from "./layoutBase.js"
 import {DatabaseBase} from "../connection/databaseBase";
+import {ApiLayoutMetadata, ApiScriptResult} from "../models/apiResults";
 
 export class Layout<T extends LayoutInterface> implements LayoutBase {
     readonly database: DatabaseBase;
     readonly records = new LayoutRecordManager<T>(this)
     readonly name: string;
-    metadata: any;
+    metadata: ApiLayoutMetadata;
 
     constructor(database: DatabaseBase, name: string) {
         this.database = database
@@ -47,47 +48,29 @@ export class Layout<T extends LayoutInterface> implements LayoutBase {
         return this.records.find()
     }
 
-    runScript(script: Script): Promise<ScriptResult> {
-        let trace = new Error()
-        return new Promise(async (resolve, reject) => {
-            let url = `${this.endpoint}/script/${encodeURIComponent(script.name)}`
-            if (script.parameter) url += "?script.param=" + encodeURIComponent(script.parameter)
-            this.database.apiRequest(url, {
-                port: 443,
-                method: "GET"
-            })
-                .then(res => {
-                    if (res.messages[0].code === "0") {
-                        let error = parseInt(res.response.scriptError)
-                        let msg: ScriptResult = {
-                            scriptError: error ? new FMError(error, 200, res, trace) : undefined,
-                            scriptResult: res.response.scriptResult
-                        }
-                        resolve(msg)
-                    }
-                    else {
-                        // console.log(res)
-                        reject(new FMError(res.messages[0].code, res.status, res, trace))
-                    }
-                })
-                .catch(e => {
-                    reject(e)
-                })
+    async runScript(script: Script): Promise<ScriptResult> {
+        let url = `${this.endpoint}/script/${encodeURIComponent(script.name)}`
+        if (script.parameter) url += "?script.param=" + encodeURIComponent(script.parameter)
+        let res = await this.database.apiRequest<ApiScriptResult>(url, {
+            port: 443,
+            method: "GET"
         })
+        if (res.messages[0].code === "0") {
+            let error = parseInt(res.response.scriptError)
+            return {
+                scriptError: error ? new FMError(error, 200, res) : undefined,
+                scriptResult: res.response.scriptResult
+            }
+        }
     }
 
-    public getLayoutMeta(): Promise<this | FMError> {
-        return new Promise((resolve, reject) => {
-            if (this.metadata) {
-                resolve(this.metadata)
-                return
-            }
+    public async getLayoutMeta(): Promise<ApiLayoutMetadata> {
+        if (this.metadata) {
+            return this.metadata
+        }
 
-            this.database.apiRequest(this.endpoint).then(res => {
-                this.metadata = res.response
-                resolve(this)
-            })
-                .catch(e => reject(e))
-        })
+        let res = await this.database.apiRequest<ApiLayoutMetadata>(this.endpoint)
+        this.metadata = res.response
+        return this.metadata
     }
 }

package/src/layouts/layoutBase.d.ts

@@ -1,11 +1,11 @@
 import { Script, ScriptResult } from "../types";
-import { FMError } from "../FMError";
 import { DatabaseBase } from "../connection/databaseBase";
+import { ApiLayoutMetadata } from "../models/apiResults";
 export interface LayoutBase {
     readonly name: string;
     metadata: any;
     endpoint: string;
     runScript(script: Script): Promise<ScriptResult>;
-    getLayoutMeta(): Promise<this | FMError>;
+    getLayoutMeta(): Promise<ApiLayoutMetadata>;
     database: DatabaseBase;
 }

package/src/layouts/layoutBase.ts

@@ -5,12 +5,13 @@
 import {Script, ScriptResult} from "../types";
 import {FMError} from "../FMError";
 import {DatabaseBase} from "../connection/databaseBase";
+import {ApiLayoutMetadata} from "../models/apiResults";
 
 export interface LayoutBase {
     readonly name: string
     metadata: any
     endpoint: string
     runScript(script: Script): Promise<ScriptResult>
-    getLayoutMeta(): Promise<this | FMError>
+    getLayoutMeta(): Promise<ApiLayoutMetadata>
     database: DatabaseBase
 }

package/src/layouts/layoutRecordManager.d.ts

@@ -7,7 +7,7 @@ export declare class LayoutRecordManager<T extends LayoutInterface> {
     readonly layout: LayoutBase;
     constructor(layout: LayoutBase);
     create(): Promise<LayoutRecord<T["fields"], T["portals"]>>;
-    get(recordId: any): Promise<LayoutRecord<T["fields"], T["portals"]>>;
+    get(recordId: number): Promise<LayoutRecord<T["fields"], T["portals"]>>;
     range(start?: number, limit?: number): RecordGetRange<T>;
     find(start?: number, limit?: number): Find<T>;
 }

package/src/layouts/layoutRecordManager.js

@@ -5,41 +5,26 @@ import { LayoutRecord } from "../records/layoutRecord.js";
 import { RecordGetRange } from "../records/getOperations/recordGetRange.js";
 import { Find } from "../records/getOperations/find.js";
 export class LayoutRecordManager {
+    layout;
     constructor(layout) {
         this.layout = layout;
     }
-    create() {
-        return new Promise((resolve, reject) => {
-            // Get the layout's metadata
-            this.layout.getLayoutMeta().then(layout => {
-                let fields = {};
-                for (let _field of this.layout.metadata.fieldMetaData) {
-                    fields[_field.name] = "";
-                }
-                let portals = {};
-                for (let _portal of Object.keys(this.layout.metadata.portalMetaData))
-                    portals[_portal] = [];
-                resolve(new LayoutRecord(this.layout, -1, 0, fields, portals));
-            }).catch(e => {
-                reject(e);
-            });
-        });
+    async create() {
+        await this.layout.getLayoutMeta();
+        let fields = {};
+        for (let _field of this.layout.metadata.fieldMetaData) {
+            fields[_field.name] = "";
+        }
+        let portals = {};
+        for (let _portal of Object.keys(this.layout.metadata.portalMetaData))
+            portals[_portal] = [];
+        return new LayoutRecord(this.layout, -1, 0, fields, portals);
     }
-    get(recordId) {
-        return new Promise((resolve, reject) => {
-            let record;
-            this.layout.getLayoutMeta()
-                .then(layout => {
-                record = new LayoutRecord(this.layout, recordId);
-                return record.get();
-            })
-                .then(() => {
-                resolve(record);
-            })
-                .catch(e => {
-                reject(e);
-            });
-        });
+    async get(recordId) {
+        await this.layout.getLayoutMeta();
+        let record = new LayoutRecord(this.layout, recordId);
+        await record.get();
+        return record;
     }
     range(start = 0, limit = 100) {
         return new RecordGetRange(this.layout, start, limit);

package/src/layouts/layoutRecordManager.ts

@@ -15,38 +15,22 @@ export class LayoutRecordManager<T extends LayoutInterface> {
         this.layout = layout
     }
 
-    create(): Promise<LayoutRecord<T["fields"], T["portals"]>> {
-        return new Promise((resolve, reject) => {
-            // Get the layout's metadata
-            this.layout.getLayoutMeta().then(layout => {
-                let fields = {}
-                for (let _field of this.layout.metadata.fieldMetaData) {
-                    fields[_field.name] = ""
-                }
-                let portals = {}
-                for (let _portal of Object.keys(this.layout.metadata.portalMetaData)) portals[_portal] = []
-                resolve(new LayoutRecord(this.layout, -1, 0, fields, portals))
-            }).catch(e => {
-                reject(e)
-            })
-        })
+    async create(): Promise<LayoutRecord<T["fields"], T["portals"]>> {
+        await this.layout.getLayoutMeta()
+        let fields = {}
+        for (let _field of this.layout.metadata.fieldMetaData) {
+            fields[_field.name] = ""
+        }
+        let portals = {}
+        for (let _portal of Object.keys(this.layout.metadata.portalMetaData)) portals[_portal] = []
+        return new LayoutRecord(this.layout, -1, 0, fields, portals)
     }
 
-    get(recordId): Promise<LayoutRecord<T["fields"], T["portals"]>> {
-        return new Promise((resolve, reject) => {
-            let record
-            this.layout.getLayoutMeta()
-                .then(layout => {
-                    record = new LayoutRecord(this.layout, recordId)
-                    return record.get()
-                })
-                .then(() => {
-                    resolve(record)
-                })
-                .catch(e => {
-                    reject(e)
-                })
-        })
+    async get(recordId: number): Promise<LayoutRecord<T["fields"], T["portals"]>> {
+        await this.layout.getLayoutMeta()
+        let record = new LayoutRecord(this.layout, recordId)
+        await record.get()
+        return record
     }
 
     range(start = 0, limit = 100) {