@jd-data-limited/easy-fm 3.1.6 → 3.2.0

package/README.md

@@ -7,7 +7,21 @@ a [FileMaker database](https://www.claris.com/filemaker/) stored on
 a [FileMaker server](https://www.claris.com/filemaker/server/)
 or [FileMaker Cloud](https://store.claris.com/filemaker-cloud). This module interacts with your server using the
 [FileMaker Data API](https://help.claris.com/en/data-api-guide/content/index.html).
-
+<!-- TOC -->
+* [easy-fm](#easy-fm)
+  * [FileMaker setup instructions](#filemaker-setup-instructions)
+  * [Before you begin](#before-you-begin)
+  * [Connecting to a database](#connecting-to-a-database)
+  * [Getting records](#getting-records)
+    * [Fetch a range of records](#fetch-a-range-of-records)
+    * [Searching for records](#searching-for-records)
+    * [Fetch a record using its record ID (NOT RECOMMENDED)](#fetch-a-record-using-its-record-id-not-recommended)
+    * [Create a record](#create-a-record)
+    * [Modify a record](#modify-a-record)
+* [Field names](#field-names)
+* [Portal names](#portal-names)
+* [Typescript Implementation](#typescript-implementation)
+<!-- TOC -->
 ## FileMaker setup instructions
 
 1. Enable the FileMaker Data API from the server's admin console. This setting is located
@@ -20,7 +34,7 @@ or [FileMaker Cloud](https://store.claris.com/filemaker-cloud). This module inte
 ## Before you begin
 
 - You need to know what your server's UTC time offset (in minutes) is.
-    - Running `0 - (new Date()).getTimezoneOffset()` in javascript will the UTC time offset for your current timezone.
+    - Running `0 - (new Date()).getTimezoneOffset()` in javascript will give you the UTC time offset for your current timezone.
 
 ## Connecting to a database
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jd-data-limited/easy-fm",
-  "version": "3.1.6",
+  "version": "3.2.0",
   "dependencies": {
     "@types/btoa": "^1.2.3",
     "@types/events": "^3.0.0",

package/src/connection/database.d.ts

@@ -1,9 +1,8 @@
 /// <reference types="node" />
-/// <reference types="node" />
 import { EventEmitter } from "events";
 import { Request } from "node-fetch";
+import { LayoutInterface } from "../layouts/layoutInterface.js";
 import { Layout } from "../layouts/layout.js";
-import * as http from "http";
 import { databaseOptionsWithExternalSources, DatabaseStructure, Script } from "../types.js";
 import { HostBase } from "./HostBase.js";
 import { DatabaseBase } from "./databaseBase";
@@ -21,8 +20,9 @@ export declare class Database<T extends DatabaseStructure> extends EventEmitter
     get endpoint(): string;
     apiRequest<T = any>(url: string | Request, options?: any, autoRelogin?: boolean): Promise<T>;
     getLayout<R extends string>(name: R): Layout<T["layouts"][R]>;
+    getLayout<R extends LayoutInterface>(name: string): Layout<R>;
     setGlobals(globalFields: any): Promise<void>;
     script(name: any, parameter?: string): Script;
     _tokenExpired(): void;
-    streamContainer(field: any, url: any): Promise<http.IncomingMessage>;
+    streamContainer(url: any): Promise<import("node-fetch").Response>;
 }

package/src/connection/database.js

@@ -15,8 +15,6 @@ import fetch from "node-fetch";
 import { generateAuthorizationHeaders } from "./generateAuthorizationHeaders.js";
 import { FMError } from "../FMError.js";
 import { Layout } from "../layouts/layout.js";
-import * as http from "http";
-import * as https from "https";
 export class Database extends EventEmitter {
     constructor(host, conn) {
         super();
@@ -158,16 +156,8 @@ export class Database extends EventEmitter {
     _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;
-            }
+    streamContainer(url) {
+        return __awaiter(this, void 0, void 0, function* () {
             let headers = {};
             if (Object.keys(this.cookies).length !== 0) {
                 headers["Cookie"] = Object.keys(this.cookies)
@@ -177,19 +167,17 @@ export class Database extends EventEmitter {
                     .join("; ");
             }
             // Automatically switch between the http and https modules, based on which is needed
-            (url.startsWith("https") ? https : http).get(url, {
+            let res = yield fetch(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);
             });
+            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;
+            }
+            return res;
         });
     }
 }

package/src/connection/database.ts

@@ -21,6 +21,8 @@ import {
 import {HostBase} from "./HostBase.js"
 import {DatabaseBase} from "./databaseBase";
 
+type GetLayoutReturnType<T extends DatabaseStructure, R extends LayoutInterface | string> = R extends string ? T["layouts"][R] : R
+
 export class Database<T extends DatabaseStructure> extends EventEmitter implements DatabaseBase {
     private _token: any;
     readonly host: HostBase;
@@ -143,8 +145,10 @@ export class Database<T extends DatabaseStructure> extends EventEmitter implemen
         return (data as any)
     }
 
-    getLayout<R extends string>(name: R): Layout<T["layouts"][R]> {
-        return new Layout<T["layouts"][R]>(this, name)
+    getLayout<R extends string>(name: R): Layout<T["layouts"][R]>
+    getLayout<R extends LayoutInterface>(name: string): Layout<R>
+    getLayout(name: string): Layout<LayoutInterface> {
+        return new Layout<LayoutInterface>(this, name)
     }
 
     setGlobals(globalFields): Promise<void> {
@@ -177,41 +181,31 @@ export class Database<T extends DatabaseStructure> extends EventEmitter implemen
         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
-            }
+    async streamContainer(url) {
 
-            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
-                }
+        let headers = {}
+        if (Object.keys(this.cookies).length !== 0) {
+            headers["Cookie"] = Object.keys(this.cookies)
+                .map(key => {
+                    return key + "=" + this.cookies[key]
+                })
+                .join("; ")
+        }
 
-                resolve(res)
-            })
+        // Automatically switch between the http and https modules, based on which is needed
+        let res = await fetch(url, {
+            headers
         })
+
+        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
+        }
+        return res
     }
+
 }

package/src/connection/databaseBase.d.ts

@@ -1,8 +1,10 @@
 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,6 +5,7 @@
 import {HostBase} from "./HostBase.js"
 import {Request} from "node-fetch";
 import {DatabaseStructure} from "../types";
+import {Response} from "node-fetch";
 
 export interface DatabaseBase {
     host: HostBase,
@@ -14,4 +15,5 @@ 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,8 +1,7 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import { RecordBase } from "./recordBase.js";
-import * as http from "http";
-import { ContainerBufferResult, DOWNLOAD_MODES, FieldMetaData } from "../types.js";
+import { ContainerDataStream, DOWNLOAD_MODES, FieldMetaData } from "../types.js";
 export type FieldValue = string | number | Date | Container;
 export type Container = null;
 export declare class Field<T extends FieldValue> {
@@ -19,6 +18,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<http.IncomingMessage>;
-    download(mode: DOWNLOAD_MODES.Buffer): Promise<ContainerBufferResult>;
+    download(mode: DOWNLOAD_MODES.Stream): Promise<ContainerDataStream<NodeJS.ReadableStream>>;
+    download(mode: DOWNLOAD_MODES.Buffer): Promise<ContainerDataStream<ArrayBuffer>>;
 }

package/src/records/field.js

@@ -149,32 +149,27 @@ export class Field {
         }));
     }
     download(mode = DOWNLOAD_MODES.Stream) {
-        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);
-            });
+        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["content-type"]
+            };
         });
     }
 }

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 {ContainerBufferResult, DOWNLOAD_MODES, FieldMetaData} from "../types.js";
+import {ContainerDataStream, DOWNLOAD_MODES, FieldMetaData} from "../types.js";
 import {FMError} from "../FMError.js";
 
 export type FieldValue = string | number | Date | Container
@@ -158,36 +158,26 @@ export class Field<T extends FieldValue> {
         })
     }
 
-    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
-                    }
+    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 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)
-                })
-        })
+        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
+        }
+
+        return {
+            data,
+            mime: res.headers["content-type"]
+        }
     }
 }

package/src/types.d.ts

@@ -1,6 +1,4 @@
 /// <reference types="node" />
-/// <reference types="node" />
-import * as http from "http";
 import { FMError } from "./FMError.js";
 import { LayoutInterface } from "./layouts/layoutInterface";
 export interface DatabaseStructure {
@@ -108,10 +106,9 @@ export interface ScriptResult {
     scriptError?: FMError;
     scriptResult?: string;
 }
-export interface ContainerBufferResult {
-    buffer: Buffer;
+export interface ContainerDataStream<T = NodeJS.ReadableStream | ArrayBuffer> {
+    data: T;
     mime: string;
-    request: http.IncomingMessage;
 }
 export interface AuthorizationHeaders {
     "Content-Type": "application/json";

package/src/types.ts

@@ -132,10 +132,9 @@ export interface ScriptResult {
     scriptResult?: string
 }
 
-export interface ContainerBufferResult {
-    buffer: Buffer,
-    mime: string,
-    request: http.IncomingMessage
+export interface ContainerDataStream<T = NodeJS.ReadableStream | ArrayBuffer> {
+    data: T,
+    mime: string
 }
 
 //