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

package/src/connection/FMHost.ts

@@ -2,88 +2,120 @@
  * Copyright (c) 2023-2024. See LICENSE file for more information
  */
 
-import {generateAuthorizationHeaders} from "./generateAuthorizationHeaders.js";
-import {FMError} from "../FMError.js";
-import {Database} from "./database.js";
-import {HostBase} from "./HostBase.js"
+import {generateAuthorizationHeaders} from './generateAuthorizationHeaders.js'
+import {FMError} from '../FMError.js'
+import {Database} from './database.js'
+import {type HostBase} from './HostBase.js'
 import {
-    databaseOptionsWithExternalSources,
-    FMHostMetadata,
-    loginOptionsClaris,
-    loginOptionsFileMaker,
-    loginOptionsOAuth
-} from "../types.js";
-import {ApiResults} from "../models/apiResults.js";
-import {DatabaseStructure} from "../databaseStructure.js";
+    type databaseOptionsWithExternalSources,
+    type FMHostMetadata,
+    type loginOptionsClaris,
+    type loginOptionsFileMaker,
+    type loginOptionsOAuth
+} from '../types.js'
+import {type ApiResults} from '../models/apiResults.js'
+import {type DatabaseStructure} from '../databaseStructure.js'
+import {type Moment} from 'moment'
 
+/**
+ * Represents a FileMaker host.
+ * @implements {HostBase}
+ */
 export default class FMHost implements HostBase {
     readonly hostname: string
-    readonly timezoneOffset: number
+    readonly timezoneOffsetFunc: (moment: Moment) => number
     readonly verify: boolean
     _metadata: FMHostMetadata | null = null
 
-    constructor(_hostname: string, timezoneOffset = 0 - (new Date()).getTimezoneOffset(), verify = true) {
-        if (!(/^https?:\/\//).test(_hostname)) throw "hostname MUST begin with either http:// or https://"
+    constructor (
+        _hostname: string,
+        timezoneOffset = (moment: 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.timezoneOffset = timezoneOffset
+        this.timezoneOffsetFunc = timezoneOffset
         this.verify = verify
     }
 
-    get metadata(): FMHostMetadata {
-        return this._metadata || {
+    get metadata (): FMHostMetadata {
+        return this._metadata ?? {
             productInfo: {
                 buildDate: new Date(),
-                name: "",
-                version: "",
-                dateFormat: "",
-                timeFormat: "",
-                timeStampFormat: ""
+                name: '',
+                version: '',
+                dateFormat: 'MM/dd/yyyy',
+                timeFormat: 'HH:mm:ss',
+                timeStampFormat: 'MM/dd/yyyy HH:mm:ss'
             }
-        };
+        }
+    }
+
+    get dateFormat () {
+        return this.metadata.productInfo.dateFormat
+            .replace('dd', 'DD')
+            .replace('yyyy', 'YYYY')
     }
 
-    async listDatabases(credentials?: loginOptionsOAuth | loginOptionsFileMaker | loginOptionsClaris) {
+    get timeFormat () { return this.metadata.productInfo.timeFormat }
+    get timeStampFormat () {
+        return this.metadata.productInfo.timeStampFormat
+            .replace('dd', 'DD')
+            .replace('yyyy', 'YYYY')
+    }
+
+    /**
+     * Retrieves a list of databases from the FileMaker Server.
+     *
+     * @param {loginOptionsOAuth | loginOptionsFileMaker | loginOptionsClaris} [credentials] - Optional credentials required for authentication.
+     * @throws {FMError} If the request to the FileMaker Server fails or if the response contains an error.
+     * @returns {Promise<any[]>} A promise that resolves to an array of database objects if successful.
+     */
+    async listDatabases (credentials?: loginOptionsOAuth | loginOptionsFileMaker | loginOptionsClaris) {
         let headers = {}
         if (credentials) {
             headers = generateAuthorizationHeaders(credentials)
         }
 
-        let _fetch = await fetch(`${this.hostname}/fmi/data/v2/databases`, {
-            method: "GET",
+        const _fetch = await fetch(`${this.hostname}/fmi/data/v2/databases`, {
+            method: 'GET',
             headers
         })
-        let data = await _fetch.json() as ApiResults<{databases: any}>
+        const data = await _fetch.json() as ApiResults<{ databases: any }>
         // console.log(data.messages[0])
 
-        if (data.messages[0].code === "0" && data.response) {
+        if (data.messages[0].code === '0' && data.response) {
             return data.response.databases
-        }
-        else {
-            // @ts-ignore
-            throw new FMError(data.messages[0].code, data.status, data)
+        } else {
+            throw new FMError(data.messages[0].code, _fetch.status, data)
         }
     }
 
+    /**
+     * Creates a new database connection with the specified options.
+     *
+     * @template T - The type of the database structure.
+     * @param {databaseOptionsWithExternalSources} data - The options for the database, including external sources.
+     * @return {Database<T>} A new Database instance.
+     */
     database<T extends DatabaseStructure>(data: databaseOptionsWithExternalSources) {
         return new Database<T>(this, data)
     }
 
-    async getMetadata() {
+    async getMetadata () {
         if (this._metadata) return this._metadata
 
-        let _fetch = await fetch(`${this.hostname}/fmi/data/v2/productInfo`, {
-            method: "GET",
+        const _fetch = await fetch(`${this.hostname}/fmi/data/v2/productInfo`, {
+            method: 'GET'
         })
-        let data = await _fetch.json() as ApiResults<FMHostMetadata>
+        const data = await _fetch.json() as ApiResults<FMHostMetadata>
         // console.log(data.messages[0])
 
-        if (data.messages[0].code === "0" && data.response) {
+        if (data.messages[0].code === '0' && data.response) {
             this._metadata = data.response
             return data.response
-        }
-        else {
-            // @ts-ignore
-            throw new FMError(data.messages[0].code, data.status, data)
+        } else {
+            throw new FMError(data.messages[0].code, _fetch.status, data)
         }
     }
-}
+}

package/src/connection/HostBase.d.ts

@@ -1,8 +1,12 @@
-import { FMHostMetadata } from "../types.js";
+import { type FMHostMetadata } from '../types.js';
+import { type Moment } from 'moment';
 export interface HostBase {
     readonly hostname: string;
-    readonly timezoneOffset: number;
+    readonly timezoneOffsetFunc: (moment: Moment) => number;
     readonly verify: boolean;
     metadata: FMHostMetadata;
-    getMetadata(): PromiseLike<any>;
+    getMetadata: () => PromiseLike<any>;
+    timeFormat: string;
+    dateFormat: string;
+    timeStampFormat: string;
 }

package/src/connection/HostBase.ts

@@ -2,12 +2,16 @@
  * Copyright (c) 2023-2024. See LICENSE file for more information
  */
 
-import {FMHostMetadata} from "../types.js";
+import {type FMHostMetadata} from '../types.js'
+import {type Moment} from 'moment'
 
 export interface HostBase {
     readonly hostname: string
-    readonly timezoneOffset: number
+    readonly timezoneOffsetFunc: (moment: Moment) => number
     readonly verify: boolean
     metadata: FMHostMetadata
-    getMetadata(): PromiseLike<any>
-}
+    getMetadata: () => PromiseLike<any>
+    timeFormat: string
+    dateFormat: string
+    timeStampFormat: string
+}

package/src/connection/database.d.ts

@@ -1,33 +1,66 @@
 /// <reference types="node" resolution-mode="require"/>
 /// <reference types="node" resolution-mode="require"/>
-import { EventEmitter } from "events";
-import { LayoutInterface } from "../layouts/layoutInterface.js";
-import { Layout } from "../layouts/layout.js";
-import { databaseOptionsWithExternalSources, Script } from "../types.js";
-import { HostBase } from "./HostBase.js";
-import { DatabaseBase } from "./databaseBase.js";
-import { ApiResults } from "../models/apiResults.js";
-import { DatabaseStructure } from "../databaseStructure.js";
-import { IncomingMessage } from "http";
+import { EventEmitter } from 'events';
+import { type LayoutInterface } from '../layouts/layoutInterface.js';
+import { Layout } from '../layouts/layout.js';
+import { type databaseOptionsWithExternalSources, type Script } from '../types.js';
+import { type HostBase } from './HostBase.js';
+import { type DatabaseBase } from './databaseBase.js';
+import { type ApiResults } from '../models/apiResults.js';
+import { type DatabaseStructure } from '../databaseStructure.js';
+import { type IncomingMessage } from 'http';
+/**
+ * Represents a database connection.
+ * @template T - The structure of the database.
+ */
 export declare class Database<T extends DatabaseStructure> extends EventEmitter implements DatabaseBase {
     private _token;
     readonly host: HostBase;
-    private connection_details;
+    private readonly connection_details;
     private cookies;
     readonly name: string;
     readonly debug: boolean;
     constructor(host: HostBase, conn: databaseOptionsWithExternalSources);
     private generateExternalSourceLogin;
+    /**
+     * Logs out the user by deleting the current session token.
+     * Throws an error if the user is not logged in.
+     *
+     * @returns {Promise<void>} A promise that resolves with no value once the logout is successful.
+     * @throws {Error} Throws an error if the user is not logged in.
+     */
     logout(): Promise<void>;
-    login(forceLogin?: boolean): Promise<any>;
-    get token(): any;
+    /**
+     * Logs in to the database. Not required, as this is often done automatically
+     *
+     * @param {boolean} [forceLogin=false] - Whether to force login even if already logged in.
+     * @throws {Error} - Throws an error if already logged in and forceLogin is false.
+     * @throws {FMError} - Throws an FMError if login fails.
+     * @return {Promise<string>} - Returns a promise that resolves to the access token upon successful login.
+     */
+    login(forceLogin?: boolean): Promise<string>;
+    get token(): string;
+    /**
+     * Returns the endpoint URL for the database connection.
+     *
+     * @returns {string} The endpoint URL.
+     */
     get endpoint(): string;
-    apiRequestRaw(url: string | Request, options?: any, autoRelogin?: boolean): Promise<Response>;
-    apiRequestJSON<T = any>(url: string | Request, options?: any): Promise<ApiResults<T>>;
+    _apiRequestRaw(url: string | Request, options?: RequestInit & {
+        headers?: Record<string, string>;
+    }, autoRelogin?: boolean): Promise<Response>;
+    _apiRequestJSON<T = any>(url: string | Request, options?: RequestInit & {
+        headers?: Record<string, string>;
+    }): Promise<ApiResults<T>>;
+    /**
+     * Retrieves a list of layouts in the current FileMaker database.
+     *
+     * @returns {Promise<Layout[]>} A promise that resolves to an array of Layout objects.
+     * @throws {FMError} If there was an error retrieving the layouts.
+     */
     listLayouts(): Promise<Layout<LayoutInterface>[]>;
-    getLayout<R extends keyof T["layouts"]>(name: R): Layout<T["layouts"][R]>;
-    getLayout<R extends LayoutInterface>(name: string): Layout<R>;
+    layout<R extends keyof T['layouts']>(name: R): Layout<T['layouts'][R]>;
+    layout<R extends LayoutInterface>(name: string): Layout<R>;
     script(name: string, parameter?: string): Script;
-    _tokenExpired(): void;
     streamURL(url: string): Promise<IncomingMessage>;
 }

package/src/connection/database.js

@@ -1,13 +1,17 @@
 /*
  * Copyright (c) 2023-2024. See LICENSE file for more information
  */
-import { EventEmitter } from "events";
-import { generateAuthorizationHeaders } from "./generateAuthorizationHeaders.js";
-import { FMError } from "../FMError.js";
-import { Layout } from "../layouts/layout.js";
-import HTTP_REDIRECT from "follow-redirects";
+import { EventEmitter } from 'events';
+import { generateAuthorizationHeaders } from './generateAuthorizationHeaders.js';
+import { FMError } from '../FMError.js';
+import { Layout } from '../layouts/layout.js';
+import HTTP_REDIRECT from 'follow-redirects';
+/**
+ * Represents a database connection.
+ * @template T - The structure of the database.
+ */
 export class Database extends EventEmitter {
-    _token;
+    _token = '';
     host;
     connection_details;
     cookies = {};
@@ -18,11 +22,12 @@ export class Database extends EventEmitter {
         this.host = host;
         this.name = conn.database;
         this.connection_details = conn;
-        this.debug = !!conn.debug;
+        this.debug = conn.debug ?? false;
     }
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
     generateExternalSourceLogin(data) {
-        if (data.credentials.method === "filemaker") {
-            let _data = data.credentials;
+        if (data.credentials.method === 'filemaker') {
+            const _data = data.credentials;
             return {
                 database: data.database,
                 username: _data.username,
@@ -30,50 +35,66 @@ export class Database extends EventEmitter {
             };
         }
         else {
-            throw "Not yet supported login method";
+            throw new Error('Not yet supported login method');
         }
     }
+    /**
+     * Logs out the user by deleting the current session token.
+     * Throws an error if the user is not logged in.
+     *
+     * @returns {Promise<void>} A promise that resolves with no value once the logout is successful.
+     * @throws {Error} Throws an error if the user is not logged in.
+     */
     async logout() {
-        if (!this.token)
-            throw new Error("Not logged in");
-        let _fetch = await fetch(`${this.endpoint}/sessions/${this.token}`, {
-            method: "DELETE",
+        if (this.token === '')
+            throw new Error('Not logged in');
+        const _fetch = await fetch(`${this.endpoint}/sessions/${this.token}`, {
+            method: 'DELETE',
             headers: {
-                "content-type": "application/json"
+                'content-type': 'application/json'
             }
         });
-        let data = await _fetch.json();
+        await _fetch.json();
         // console.log(data)
-        this._token = null;
+        this._token = '';
     }
+    /**
+     * Logs in to the database. Not required, as this is often done automatically
+     *
+     * @param {boolean} [forceLogin=false] - Whether to force login even if already logged in.
+     * @throws {Error} - Throws an error if already logged in and forceLogin is false.
+     * @throws {FMError} - Throws an FMError if login fails.
+     * @return {Promise<string>} - Returns a promise that resolves to the access token upon successful login.
+     */
     async login(forceLogin = false) {
+        // console.trace()
         // Reset cookies
         this.cookies = {};
         await this.host.getMetadata();
-        if (this.token && !forceLogin)
-            throw new Error("Already logged in. Run logout() first");
-        if (this.connection_details.credentials.method === "token") {
-            this._token = this.connection_details.credentials.token;
+        if (this.token !== '' && !forceLogin)
+            throw new Error('Already logged in. Run logout() first');
+        if (this.connection_details.credentials.method === 'token') {
+            this._token = (this.connection_details.credentials).token;
             return this.token;
         }
         else {
             console.time();
-            let url = new URL(`${this.endpoint}/sessions`);
+            const url = new URL(`${this.endpoint}/sessions`);
             url.hostname = this.host.hostname;
-            let res = await fetch(url, {
-                method: "POST",
+            const res = await fetch(url, {
+                method: 'POST',
                 headers: generateAuthorizationHeaders(this.connection_details.credentials),
                 body: JSON.stringify({
                     fmDataSource: this.connection_details.externalSources.map(i => {
-                        let _i = i;
+                        const _i = i;
                         return this.generateExternalSourceLogin(_i);
                     })
                 })
             });
             console.time();
-            let _res = (await res.json());
+            const _res = (await res.json());
             if (res.status === 200) {
-                this._token = res.headers.get('x-fm-data-access-token');
+                this._token = res.headers.get('x-fm-data-access-token') ?? '';
                 return this._token;
             }
             else {
@@ -84,54 +105,65 @@ export class Database extends EventEmitter {
     get token() {
         return this._token;
     }
+    /**
+     * Returns the endpoint URL for the database connection.
+     *
+     * @returns {string} The endpoint URL.
+     */
     get endpoint() {
         return `${this.host.hostname}/fmi/data/v2/databases/${this.name}`;
     }
-    async apiRequestRaw(url, options = {}, autoRelogin = true) {
+    async _apiRequestRaw(url, options = {}, autoRelogin = true) {
         if (this.debug)
-            console.log(`EASYFM DEBUG: ${options.method?.toString().toUpperCase() || "GET"} ${url instanceof Request ? url.url : url}`);
-        if (!this.token)
+            console.log(`EASYFM DEBUG: ${JSON.stringify(options)} ${url instanceof Request ? url.url : url}`);
+        if (this.token === '')
             await this.login(true);
         if (!options.headers)
             options.headers = {};
-        options.headers["authorization"] = "Bearer " + this._token;
-        options.rejectUnauthorized = this.host.verify;
-        let _fetch = await fetch(url, options);
+        options.headers.authorization = 'Bearer ' + this._token;
+        // options.rejectUnauthorized = this.host.verify
+        const _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.cookies[cookie_split[0]] = cookie_split[1];
+            for (const cookie of _fetch.headers.get('set-cookie') ?? []) {
+                const cookieSplit = cookie.split('=');
+                this.cookies[cookieSplit[0]] = cookieSplit[1];
             }
         }
         if (_fetch.status === 401 && autoRelogin) {
             await this.login(true);
-            return await this.apiRequestRaw(url, options, false);
+            return await this._apiRequestRaw(url, options, false);
         }
         return _fetch;
     }
-    async apiRequestJSON(url, options = {}) {
+    async _apiRequestJSON(url, options = {}) {
         if (!options.headers)
             options.headers = {};
-        options.headers["content-type"] = options.headers["content-type"] ? options.headers["content-type"] : "application/json";
-        let _fetch = await this.apiRequestRaw(url, options);
-        let data = await _fetch.json();
+        options.headers['content-type'] = options.headers['content-type'] ? options.headers['content-type'] : 'application/json';
+        const _fetch = await this._apiRequestRaw(url, options);
+        const data = await _fetch.json();
         // Remove response if it is empty. This makes checking for an empty response easier
         if (data.response && Object.keys(data.response).length === 0)
             delete data.response;
         // console.log(data.messages[0])
-        if (data.messages[0].code !== "0") {
+        if (data.messages[0].code !== '0') {
             throw new FMError(data.messages[0].code, _fetch.status, data);
         }
         data.httpStatus = _fetch.status;
         return data;
     }
+    /**
+     * Retrieves a list of layouts in the current FileMaker database.
+     *
+     * @returns {Promise<Layout[]>} A promise that resolves to an array of Layout objects.
+     * @throws {FMError} If there was an error retrieving the layouts.
+     */
     async listLayouts() {
-        let req = await this.apiRequestJSON(`${this.endpoint}/layouts?page=2`);
+        const req = await this._apiRequestJSON(`${this.endpoint}/layouts?page=2`);
         if (!req.response)
             throw new FMError(req.messages[0].code, req.httpStatus, req.messages[0].message);
         const cycleLayoutNames = (layouts) => {
             let names = [];
-            for (let layout of layouts) {
+            for (const layout of layouts) {
                 if (layout.folderLayoutNames)
                     names = names.concat(cycleLayoutNames(layout.folderLayoutNames));
                 else
@@ -139,47 +171,43 @@ export class Database extends EventEmitter {
             }
             return names;
         };
-        let layoutNames;
         return cycleLayoutNames(req.response.layouts).map(layout => new Layout(this, layout));
     }
-    getLayout(name) {
+    layout(name) {
         return new Layout(this, name);
     }
-    script(name, parameter = "") {
-        return { name, parameter };
-    }
-    _tokenExpired() {
-        this.emit("token_expired");
+    script(name, parameter = '') {
+        return ({ name, parameter });
     }
-    streamURL(url) {
-        return new Promise((resolve, reject) => {
-            if (!url || typeof url !== "string") {
-                throw new Error("URL is empty, or has invalid value");
+    async streamURL(url) {
+        return await new Promise((resolve, reject) => {
+            if (!url || typeof url !== 'string') {
+                throw new Error('URL is empty, or has invalid value');
             }
-            let headers = {};
+            const headers = {};
             if (Object.keys(this.cookies).length !== 0) {
-                headers["Cookie"] = Object.keys(this.cookies)
+                headers.Cookie = Object.keys(this.cookies)
                     .map(key => {
-                    return key + "=" + this.cookies[key];
+                    return key + '=' + this.cookies[key];
                 })
-                    .join("; ");
+                    .join('; ');
             }
-            const check_for_cookies = (res) => {
+            const checkForCookies = (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];
+                    for (const cookie of res.headers['set-cookie']) {
+                        const cookieSplit = cookie.split('=');
+                        this.cookies[cookieSplit[0]] = cookieSplit[1];
                     }
                     res.headers['set-cookie'] = undefined;
                 }
             };
             // Automatically switch between the http and https modules, based on which is needed
-            (url.startsWith("https") ? HTTP_REDIRECT.https : HTTP_REDIRECT.http).get(url, {
+            (url.startsWith('https') ? HTTP_REDIRECT.https : HTTP_REDIRECT.http).get(url, {
                 headers,
-                beforeRedirect: (options, res) => check_for_cookies(res)
+                beforeRedirect: (options, res) => { checkForCookies(res); }
             }, (res) => {
-                check_for_cookies(res);
+                checkForCookies(res);
                 resolve(res);
             });
         });