@jd-data-limited/easy-fm 3.0.10 → 3.1.0

package/src/connection/FMHost.d.ts

@@ -0,0 +1,12 @@
+import { Database } from "./database";
+import { databaseOptionsWithExternalSources, FMHostMetadata, loginOptionsClaris, loginOptionsFileMaker, loginOptionsOAuth } from "../types.js";
+export default class FMHost {
+    readonly hostname: string;
+    readonly timezoneOffset: number;
+    readonly verify: boolean;
+    metadata: FMHostMetadata;
+    constructor(_hostname: string, timezoneOffset?: number, verify?: boolean);
+    listDatabases(credentials?: loginOptionsOAuth | loginOptionsFileMaker | loginOptionsClaris): Promise<any>;
+    database(data: databaseOptionsWithExternalSources): Database;
+    getMetadata(): Promise<any>;
+}

package/src/connection/FMHost.js

@@ -0,0 +1,68 @@
+/*
+ * 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 { generateAuthorizationHeaders } from "./generateAuthorizationHeaders";
+import fetch from "node-fetch";
+import { FMError } from "../FMError";
+import { Database } from "./database";
+export default class FMHost {
+    constructor(_hostname, timezoneOffset = 0 - (new Date()).getTimezoneOffset(), verify = true) {
+        if (!(/^https?:\/\//).test(_hostname))
+            throw "hostname MUST begin with either http:// or https://";
+        this.hostname = _hostname;
+        this.timezoneOffset = timezoneOffset;
+        this.verify = verify;
+    }
+    listDatabases(credentials) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let headers = {};
+            if (credentials) {
+                headers = generateAuthorizationHeaders(credentials);
+            }
+            let _fetch = yield fetch(`${this.hostname}/fmi/data/v2/databases`, {
+                method: "GET",
+                headers
+            });
+            let data = yield _fetch.json();
+            // console.log(data.messages[0])
+            if (data.messages[0].code === "0") {
+                return data.response.databases;
+            }
+            else {
+                // @ts-ignore
+                throw new FMError(data.messages[0].code, data.status, data);
+            }
+        });
+    }
+    database(data) {
+        return new Database(this, data);
+    }
+    getMetadata() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.metadata)
+                return this.metadata;
+            let _fetch = yield fetch(`${this.hostname}/fmi/data/v2/productInfo`, {
+                method: "GET",
+            });
+            let data = yield _fetch.json();
+            // console.log(data.messages[0])
+            if (data.messages[0].code === "0") {
+                this.metadata = data.response;
+                return data.response;
+            }
+            else {
+                // @ts-ignore
+                throw new FMError(data.messages[0].code, data.status, data);
+            }
+        });
+    }
+}

package/src/connection/FMHost.ts

@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2023. See LICENSE file for more information
+ */
+
+import {generateAuthorizationHeaders} from "./generateAuthorizationHeaders";
+import fetch from "node-fetch";
+import {FMError} from "../FMError";
+import {Database} from "./database";
+import {
+    databaseOptionsWithExternalSources,
+    fileMakerResponse,
+    FMHostMetadata,
+    loginOptionsClaris,
+    loginOptionsFileMaker,
+    loginOptionsOAuth
+} from "../types.js";
+
+export default class FMHost {
+    readonly hostname: string
+    readonly timezoneOffset: number
+    readonly verify: boolean
+    metadata: FMHostMetadata
+
+    constructor(_hostname: string, timezoneOffset = 0 - (new Date()).getTimezoneOffset(), verify = true) {
+        if (!(/^https?:\/\//).test(_hostname)) throw "hostname MUST begin with either http:// or https://"
+        this.hostname = _hostname
+        this.timezoneOffset = timezoneOffset
+        this.verify = verify
+    }
+
+    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",
+            headers
+        })
+        let data = await _fetch.json() as fileMakerResponse
+        // console.log(data.messages[0])
+
+        if (data.messages[0].code === "0") {
+            return data.response.databases
+        }
+        else {
+            // @ts-ignore
+            throw new FMError(data.messages[0].code, data.status, data)
+        }
+    }
+
+    database(data: databaseOptionsWithExternalSources) {
+        return new Database(this, data)
+    }
+
+    async getMetadata() {
+        if (this.metadata) return this.metadata
+
+        let _fetch = await fetch(`${this.hostname}/fmi/data/v2/productInfo`, {
+            method: "GET",
+        })
+        let data = await _fetch.json() as fileMakerResponse
+        // console.log(data.messages[0])
+
+        if (data.messages[0].code === "0") {
+            this.metadata = data.response
+            return data.response
+        }
+        else {
+            // @ts-ignore
+            throw new FMError(data.messages[0].code, data.status, data)
+        }
+    }
+}

package/src/connection/database.d.ts

@@ -0,0 +1,26 @@
+import { EventEmitter } from "events";
+import { Request } from "node-fetch";
+import { LayoutInterface } from "../layouts/layoutInterface";
+import { Layout } from "../layouts/layout";
+import * as http from "http";
+import { databaseOptionsWithExternalSources, Script } from "../types.js";
+import FMHost from "./FMHost";
+export declare class Database extends EventEmitter {
+    private _token;
+    readonly host: FMHost;
+    private connection_details;
+    private cookies;
+    readonly name: string;
+    constructor(host: FMHost, conn: databaseOptionsWithExternalSources);
+    private generateExternalSourceLogin;
+    logout(): Promise<void>;
+    login(): Promise<string>;
+    get token(): any;
+    get endpoint(): string;
+    apiRequest(url: string | Request, options?: any, autoRelogin?: boolean): Promise<any>;
+    getLayout<T extends LayoutInterface>(name: any): Layout<T>;
+    setGlobals(globalFields: any): Promise<void>;
+    script(name: any, parameter?: string): Script;
+    _tokenExpired(): void;
+    streamContainer(field: any, url: any): Promise<http.IncomingMessage>;
+}

package/src/connection/database.js

@@ -0,0 +1,195 @@
+/*
+ * 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 { EventEmitter } from "events";
+import fetch from "node-fetch";
+import { generateAuthorizationHeaders } from "./generateAuthorizationHeaders";
+import { FMError } from "../FMError";
+import { Layout } from "../layouts/layout";
+import * as http from "http";
+import * as https from "https";
+export class Database extends EventEmitter {
+    constructor(host, conn) {
+        super();
+        this.cookies = {};
+        this.host = host;
+        this.name = conn.database;
+        this.connection_details = conn;
+    }
+    generateExternalSourceLogin(data) {
+        if (data.credentials.method === "filemaker") {
+            let _data = data.credentials;
+            return {
+                database: data.database,
+                username: _data.username,
+                password: _data.password
+            };
+        }
+        else {
+            throw "Not yet supported login method";
+        }
+    }
+    logout() {
+        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.endpoint}/sessions/${this.token}`, {
+                method: "DELETE",
+                headers: {
+                    "content-type": "application/json"
+                }
+            });
+            let data = yield _fetch.json();
+            // console.log(data)
+            this._token = null;
+            resolve();
+        }));
+    }
+    login() {
+        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+            // Reset cookies
+            this.cookies = {};
+            try {
+                yield this.host.getMetadata();
+            }
+            catch (e) {
+                reject(e);
+                return;
+            }
+            if (this.token)
+                throw new Error("Already logged in. Run logout() first");
+            if (this.connection_details.credentials.method === "token") {
+                this._token = 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),
+                    body: JSON.stringify({
+                        fmDataSource: this.connection_details.externalSources.map(i => {
+                            let _i = i;
+                            return this.generateExternalSourceLogin(_i);
+                        })
+                    })
+                }).then((res) => __awaiter(this, void 0, void 0, function* () {
+                    let _res = (yield 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);
+                });
+            }
+        }));
+    }
+    get token() {
+        return this._token;
+    }
+    get endpoint() {
+        return `${this.host.hostname}/fmi/data/v2/databases/${this.name}`;
+    }
+    apiRequest(url, options = {}, autoRelogin = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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;
+            options.rejectUnauthorized = this.host.verify;
+            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.cookies[cookie_split[0]] = cookie_split[1];
+                }
+            }
+            let data = yield _fetch.json();
+            // console.log(data.messages[0])
+            if (data.messages[0].code == 952 && autoRelogin) {
+                this._token = null;
+                yield this.login();
+                return yield this.apiRequest(url, options, false);
+            }
+            return data;
+        });
+    }
+    getLayout(name) {
+        return new Layout(this, name);
+    }
+    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);
+            });
+        });
+    }
+    script(name, parameter = "") {
+        return { name, parameter };
+    }
+    _tokenExpired() {
+        this.emit("token_expired");
+    }
+    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)
+                    .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;
+                }
+                resolve(res);
+            });
+        });
+    }
+}

package/src/connection/database.ts

@@ -0,0 +1,216 @@
+/*
+ * Copyright (c) 2023. See LICENSE file for more information
+ */
+
+import {EventEmitter} from "events";
+import fetch, {HeadersInit, Request} from "node-fetch";
+import {generateAuthorizationHeaders} from "./generateAuthorizationHeaders";
+import {FMError} from "../FMError";
+import {LayoutInterface} from "../layouts/layoutInterface";
+import {Layout} from "../layouts/layout";
+import * as http from "http";
+import * as https from "https";
+import {
+    databaseOptionsBase,
+    databaseOptionsWithExternalSources,
+    fileMakerResponse,
+    loginOptionsFileMaker,
+    loginOptionsToken,
+    Script
+} from "../types.js";
+import FMHost from "./FMHost";
+
+export class Database extends EventEmitter {
+    private _token: any;
+    readonly host: FMHost;
+    private connection_details: databaseOptionsWithExternalSources
+    private cookies: { [key: string]: string } = {}
+    readonly name: string;
+
+    constructor(host: FMHost, conn: databaseOptionsWithExternalSources) {
+        super()
+        this.host = host
+        this.name = conn.database
+        this.connection_details = conn
+    }
+
+    private generateExternalSourceLogin(data: databaseOptionsBase) {
+        if (data.credentials.method === "filemaker") {
+            let _data = <loginOptionsFileMaker>data.credentials
+            return {
+                database: data.database,
+                username: _data.username,
+                password: _data.password
+            }
+        }
+        else {
+            throw "Not yet supported login method"
+        }
+    }
+
+    logout(): Promise<void> {
+        return new Promise(async (resolve, reject) => {
+            if (!this.token) reject(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()
+        })
+    }
+
+    login() {
+        return new Promise<string>(async (resolve, reject) => {
+            // 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")
+
+            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)
+                        })
+                    })
+                }).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)
+                    })
+            }
+        })
+    }
+
+    get token() {
+        return this._token
+    }
+
+    get endpoint(): string {
+        return `${this.host.hostname}/fmi/data/v2/databases/${this.name}`
+    }
+
+    async apiRequest(url: string | Request, options: any = {}, autoRelogin = true): Promise<any> {
+        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
+        options.rejectUnauthorized = this.host.verify
+
+        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.cookies[cookie_split[0]] = cookie_split[1]
+            }
+        }
+        let data = await _fetch.json() as fileMakerResponse
+        // console.log(data.messages[0])
+        if (data.messages[0].code == 952 && autoRelogin) {
+            this._token = null
+            await this.login()
+            return await this.apiRequest(url, options, false)
+        }
+        return (data as any)
+    }
+
+    getLayout<T extends LayoutInterface>(name): Layout<T> {
+        return new Layout(this, name)
+    }
+
+    setGlobals(globalFields): Promise<void> {
+        // 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)
+                })
+        })
+    }
+
+    script(name, parameter = ""): Script {
+        return ({name, parameter} as Script)
+    }
+
+    _tokenExpired() {
+        this.emit("token_expired")
+    }
+
+    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("; ")
+            }
+
+            // 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
+                }
+
+                resolve(res)
+            })
+        })
+    }
+}

package/src/connection/generateAuthorizationHeaders.d.ts

@@ -0,0 +1,2 @@
+import { AuthorizationHeaders, AuthorizationHeadersOAuth, loginOptionsClaris, loginOptionsFileMaker, loginOptionsOAuth } from "../types.js";
+export declare function generateAuthorizationHeaders(credentials: loginOptionsOAuth | loginOptionsFileMaker | loginOptionsClaris): AuthorizationHeaders | AuthorizationHeadersOAuth;

package/src/connection/generateAuthorizationHeaders.js

@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2023. See LICENSE file for more information
+ */
+export function generateAuthorizationHeaders(credentials) {
+    switch (credentials.method) {
+        case "filemaker":
+            return {
+                "Content-Type": "application/json",
+                "Authorization": "Basic " + Buffer.from(credentials.username + ":" + credentials.password).toString("base64")
+            };
+        case "claris":
+            return {
+                "Content-Type": "application/json",
+                "Authorization": credentials.claris.fmid,
+            };
+        case "oauth":
+            return {
+                "Content-Type": "application/json",
+                "X-FM-Data-OAuth-RequestId": credentials.oauth.requestId,
+                "X-FM-Data-OAuth-Identifier": credentials.oauth.requestIdentifier
+            };
+    }
+}

package/src/connection/generateAuthorizationHeaders.ts

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2023. See LICENSE file for more information
+ */
+
+import {
+    AuthorizationHeaders,
+    AuthorizationHeadersOAuth,
+    loginOptionsClaris,
+    loginOptionsFileMaker,
+    loginOptionsOAuth
+} from "../types.js";
+
+export function generateAuthorizationHeaders(credentials: loginOptionsOAuth | loginOptionsFileMaker | loginOptionsClaris): AuthorizationHeaders | AuthorizationHeadersOAuth {
+    switch (credentials.method) {
+        case "filemaker":
+            return {
+                "Content-Type": "application/json",
+                "Authorization": "Basic " + Buffer.from((<loginOptionsFileMaker>credentials).username + ":" + (<loginOptionsFileMaker>credentials).password).toString("base64")
+            } as AuthorizationHeaders
+        case "claris":
+            return {
+                "Content-Type": "application/json",
+                "Authorization": (<loginOptionsClaris>credentials).claris.fmid,
+            } as AuthorizationHeaders
+        case "oauth":
+            return {
+                "Content-Type": "application/json",
+                "X-FM-Data-OAuth-RequestId": (<loginOptionsOAuth>credentials).oauth.requestId,
+                "X-FM-Data-OAuth-Identifier": (<loginOptionsOAuth>credentials).oauth.requestIdentifier
+            } as AuthorizationHeadersOAuth
+    }
+}

package/src/index.d.ts

@@ -0,0 +1,2 @@
+import FMHost from "./connection/FMHost";
+export default FMHost;