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

package/src/records/field.ts

@@ -0,0 +1,189 @@
+/*
+ * Copyright (c) 2023. See LICENSE file for more information
+ */
+
+import {RecordBase} from "./recordBase";
+import fetch, {File, FormData} from "node-fetch";
+import * as http from "http";
+import {ContainerBufferResult, DOWNLOAD_MODES, FieldMetaData} from "../types.js";
+import {PortalRecord} from "./portalRecord";
+import {FieldValue} from "../layouts/layoutInterface";
+import {FMError} from "../FMError";
+
+export class Field<T extends FieldValue> {
+    record: RecordBase<any>;
+    id: string;
+    protected _value: T;
+    edited: boolean;
+
+    constructor(record, id, contents) {
+        this.record = record
+        this.id = id
+        this._value = contents
+        this.edited = false
+    }
+
+    set(content: string | number | Date | undefined | null) {
+        if (this.metadata.result === "container") throw "Cannot set container value using set(). Use upload() instead."
+        if (
+            (this.metadata.result === "timeStamp" ||
+                this.metadata.result === "date" ||
+                this.metadata.result === "time")
+            && !(content instanceof Date) && !!content
+        ) {
+            throw "Value was not an instance of Date: " + content
+        }
+        // @ts-ignore
+        if (!content) this._value = ""
+        // @ts-ignore
+        else this._value = content
+        this.edited = true
+    }
+
+    get metadata(): FieldMetaData {
+        if (!this.record.layout.metadata) {
+            // Default to a regular text field
+            return {
+                name: this.id.toString(),
+                type: 'normal',
+                displayType: 'editText',
+                result: 'text',
+                global: false,
+                autoEnter: true,
+                fourDigitYear: false,
+                maxRepeat: 1,
+                maxCharacters: 0,
+                notEmpty: false,
+                numeric: false,
+                timeOfDay: false,
+                repetitionStart: 1,
+                repetitionEnd: 1
+            } as FieldMetaData
+        }
+        if (this.record instanceof PortalRecord) {
+            return this.record.layout.metadata.portalMetaData[this.record.portal.name || "portal not attached"].find(i => i.name === this.id) as FieldMetaData || {
+                name: this.id.toString(),
+                type: 'normal',
+                displayType: 'editText',
+                result: 'text',
+                global: false,
+                autoEnter: true,
+                fourDigitYear: false,
+                maxRepeat: 1,
+                maxCharacters: 0,
+                notEmpty: false,
+                numeric: false,
+                timeOfDay: false,
+                repetitionStart: 1,
+                repetitionEnd: 1
+            } as FieldMetaData
+        }
+        else {
+            return this.record.layout.metadata.fieldMetaData.find(i => i.name === this.id) as FieldMetaData || {
+                name: this.id.toString(),
+                type: 'normal',
+                displayType: 'editText',
+                result: 'text',
+                global: false,
+                autoEnter: true,
+                fourDigitYear: false,
+                maxRepeat: 1,
+                maxCharacters: 0,
+                notEmpty: false,
+                numeric: false,
+                timeOfDay: false,
+                repetitionStart: 1,
+                repetitionEnd: 1
+            } as FieldMetaData
+        }
+    }
+
+    get value(): T {
+        // if (this.metadata.result === "container") throw "Use await field.stream() to get the contents of a container field, instead of field.value"
+        return this._value
+    }
+
+    set value(value: T) {
+        this._value = value
+    }
+
+    get string(): string {
+        if (typeof this._value === "string") {
+            return this._value
+        }
+        throw "Field value is not a string"
+    }
+
+    get date(): Date {
+        if (this._value instanceof Date) {
+            return this._value
+        }
+        throw "Field value is not a date"
+    }
+
+    get number(): number {
+        if (typeof this._value === "number") {
+            return this._value
+        }
+        throw "Field value is not a number"
+    }
+
+    upload(buffer: Buffer, filename: string, mime: string): Promise<void> {
+        let trace = new Error()
+        if (this.metadata.result !== "container") throw "Cannot upload a file to the field; " + this.id + " (not a container field)"
+        return new Promise(async (resolve, reject) => {
+            let form = new FormData()
+            form.append("upload", new File([buffer], filename, {type: mime}))
+
+            let _fetch = await fetch(`${this.record.endpoint}/containers/${this.id}/1`, {
+                method: "POST",
+                headers: {"Authorization": "Bearer " + this.record.layout.database.token},
+                body: form
+            }).then(res => res.json())
+                .then(data => {
+                    let _res = data as any
+                    if (_res.messages[0].code === "0") {
+                        resolve()
+                    }
+                    else {
+                        reject(new FMError(_res.messages[0].code, _res.status, data, trace))
+                    }
+                })
+                .catch(e => {
+                    reject(e)
+                })
+        })
+    }
+
+    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) => {
+            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
+                        } as ContainerBufferResult)
+                    })
+                })
+                .catch(e => {
+                    reject(e)
+                })
+        })
+    }
+}

package/src/records/getOperations/find.d.ts

@@ -0,0 +1,15 @@
+import { RecordGetOperation } from "./recordGetOperation";
+import { LayoutRecord } from "../layoutRecord";
+import { LayoutInterface } from "../../layouts/layoutInterface";
+import { Layout } from "../../layouts/layout";
+export declare class Find<T extends LayoutInterface> extends RecordGetOperation<T> {
+    protected queries: object[];
+    constructor(layout: Layout<T>, start?: number, limit?: number);
+    private toObject;
+    addRequests(...requests: any[]): this;
+    /**
+     * @deprecated in favour of .fetch()
+     */
+    run(): Promise<LayoutRecord<T["fields"], T["portals"]>[]>;
+    fetch(): Promise<LayoutRecord<T["fields"], T["portals"]>[]>;
+}

package/src/records/getOperations/find.js

@@ -0,0 +1,90 @@
+/*
+ * 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 { RecordGetOperation } from "./recordGetOperation";
+import { LayoutRecord } from "../layoutRecord";
+import { FMError } from "../../FMError";
+export class Find extends RecordGetOperation {
+    constructor(layout, start = 0, limit = 100) {
+        super(layout);
+        this.setOffset(start);
+        this.setLimit(limit);
+        this.queries = [];
+    }
+    toObject() {
+        let out = { query: this.queries, sort: undefined };
+        if (this.sort.length !== 0)
+            out.sort = this.sort;
+        for (let item of Object.keys(this.scripts)) {
+            if (this.scripts[item]) {
+                out[item] = this.scripts[item].name;
+                if (this.scripts[item].parameter)
+                    out[item + ".param"] = this.scripts[item].parameter;
+            }
+        }
+        if (this.limit !== 100)
+            out["limit"] = this.limit;
+        if (this.offset !== 0)
+            out["offset"] = this.offset;
+        if (this.limitPortals.length > 0) {
+            out["portal"] = this.limitPortals.map(p => p.portal.name);
+            for (let item of this.limitPortals) {
+                out["offset." + item.portal.name.replace(/[^0-9A-z]/g, "")] = item.offset;
+                out["limit." + item.portal.name.replace(/[^0-9A-z]/g, "")] = item.limit;
+            }
+        }
+        return out;
+    }
+    addRequests(...requests) {
+        for (let item of requests)
+            this.queries.push(item);
+        return this;
+    }
+    /**
+     * @deprecated in favour of .fetch()
+     */
+    run() {
+        return this.fetch();
+    }
+    fetch() {
+        let trace = new Error();
+        return new Promise((resolve, reject) => {
+            // console.log(this.#toObject())
+            this.layout.getLayoutMeta()
+                .then(() => {
+                return this.layout.database.apiRequest(`${this.layout.endpoint}/_find`, {
+                    port: 443,
+                    method: "POST",
+                    body: JSON.stringify(this.toObject())
+                });
+            })
+                .then((res) => __awaiter(this, void 0, void 0, function* () {
+                // // console.log(res)
+                if (res.messages[0].code === "0") {
+                    // console.log("RESOLVING")
+                    if (!this.layout.metadata)
+                        yield this.layout.getLayoutMeta();
+                    let data = res.response.data.map(item => {
+                        return new LayoutRecord(this.layout, item.recordId, item.modId, item.fieldData, item.portalData);
+                    });
+                    resolve(data);
+                }
+                else {
+                    reject(new FMError(res.messages[0].code, res.status, res, trace));
+                }
+            }))
+                .catch(e => {
+                reject(e);
+            });
+        });
+    }
+}

package/src/records/getOperations/find.ts

@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2023. See LICENSE file for more information
+ */
+
+import {RecordGetOperation} from "./recordGetOperation";
+import {LayoutRecord} from "../layoutRecord";
+import {LayoutInterface} from "../../layouts/layoutInterface";
+import {Layout} from "../../layouts/layout";
+import {FMError} from "../../FMError";
+
+export class Find<T extends LayoutInterface> extends RecordGetOperation<T> {
+    protected queries: object[]
+
+    constructor(layout: Layout<T>, start = 0, limit = 100) {
+        super(layout)
+        this.setOffset(start)
+        this.setLimit(limit)
+        this.queries = []
+    }
+
+    private toObject() {
+        let out = {query: this.queries, sort: undefined}
+        if (this.sort.length !== 0) out.sort = this.sort
+
+        for (let item of Object.keys(this.scripts)) {
+            if (this.scripts[item]) {
+                out[item] = this.scripts[item].name
+                if (this.scripts[item].parameter) out[item + ".param"] = this.scripts[item].parameter
+            }
+        }
+
+        if (this.limit !== 100) out["limit"] = this.limit
+        if (this.offset !== 0) out["offset"] = this.offset
+        if (this.limitPortals.length > 0) {
+            out["portal"] = this.limitPortals.map(p => p.portal.name)
+            for (let item of this.limitPortals) {
+                out["offset." + item.portal.name.replace(/[^0-9A-z]/g, "")] = item.offset
+                out["limit." + item.portal.name.replace(/[^0-9A-z]/g, "")] = item.limit
+            }
+        }
+
+        return out
+    }
+
+    addRequests(...requests) {
+        for (let item of requests) this.queries.push(item)
+        return this
+    }
+
+    /**
+     * @deprecated in favour of .fetch()
+     */
+    run() {
+        return this.fetch()
+    }
+
+    fetch(): Promise<LayoutRecord<T["fields"], T["portals"]>[]> {
+        let trace = new Error()
+        return new Promise((resolve, reject) => {
+            // console.log(this.#toObject())
+            this.layout.getLayoutMeta()
+                .then(() => {
+                    return this.layout.database.apiRequest(`${this.layout.endpoint}/_find`, {
+                        port: 443,
+                        method: "POST",
+                        body: JSON.stringify(this.toObject())
+                    })
+                })
+                .then(async res => {
+                    // // console.log(res)
+                    if (res.messages[0].code === "0") {
+                        // console.log("RESOLVING")
+                        if (!this.layout.metadata) await this.layout.getLayoutMeta()
+                        let data = res.response.data.map(item => {
+                            return new LayoutRecord(this.layout, item.recordId, item.modId, item.fieldData, item.portalData)
+                        })
+                        resolve(data)
+                    }
+                    else {
+                        reject(new FMError(res.messages[0].code, res.status, res, trace))
+                    }
+                })
+                .catch(e => {
+                    reject(e)
+                })
+        })
+    }
+}

package/src/records/getOperations/recordGetOperation.d.ts

@@ -0,0 +1,17 @@
+import { LayoutInterface } from "../../layouts/layoutInterface";
+import { Layout } from "../../layouts/layout";
+import { Portal } from "../portal";
+import { limitPortalsInterface } from "../../types.js";
+export declare class RecordGetOperation<T extends LayoutInterface> {
+    protected layout: Layout<T>;
+    protected limit: number;
+    protected scripts: object;
+    protected sort: object[];
+    protected limitPortals: limitPortalsInterface[];
+    protected offset: number;
+    constructor(layout: Layout<T>);
+    addToPortalLimit(portal: Portal<any>, offset?: number, limit?: number): this;
+    setLimit(limit: number): this;
+    addSort(fieldName: any, sortOrder: any): this;
+    setOffset(offset: number): this;
+}

package/src/records/getOperations/recordGetOperation.js

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2023. See LICENSE file for more information
+ */
+export class RecordGetOperation {
+    constructor(layout) {
+        this.limit = 100;
+        this.limitPortals = [];
+        this.offset = 0;
+        this.layout = layout;
+        this.scripts = {
+            "script": null,
+            "script.prerequeset": null,
+            "script.presort": null // Runs before the sort
+        };
+        this.sort = [];
+    }
+    /*
+    addToPortalLimit() will adjust the results of the get request so that if a layout has multiple portals in it,
+    only data from the specified ones will be read. This may help reduce load on your FileMaker API
+    */
+    addToPortalLimit(portal, offset = 0, limit = 100) {
+        if (offset < 0)
+            throw "Portal offset cannot be less than 0";
+        this.limitPortals.push({ portal, offset, limit });
+        return this;
+    }
+    setLimit(limit) {
+        if (limit < 1)
+            throw "Record limit too low";
+        this.limit = limit;
+        return this;
+    }
+    addSort(fieldName, sortOrder) {
+        this.sort.push({ fieldName, sortOrder });
+        return this;
+    }
+    setOffset(offset) {
+        if (offset < 0)
+            throw "Record offset too low";
+        this.limit = offset;
+        return this;
+    }
+}

package/src/records/getOperations/recordGetOperation.ts

@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2023. See LICENSE file for more information
+ */
+
+import {LayoutInterface} from "../../layouts/layoutInterface";
+import {Layout} from "../../layouts/layout";
+import {Portal} from "../portal";
+import {limitPortalsInterface} from "../../types.js";
+
+export class RecordGetOperation<T extends LayoutInterface> {
+    protected layout: Layout<T>
+    protected limit: number = 100
+    protected scripts: object
+    protected sort: object[]
+    protected limitPortals: limitPortalsInterface[] = []
+    protected offset: number = 0
+
+    constructor(layout: Layout<T>) {
+        this.layout = layout
+        this.scripts = {
+            "script": null, // Runs after everything
+            "script.prerequeset": null, // Runs before the request
+            "script.presort": null // Runs before the sort
+        }
+        this.sort = []
+    }
+
+    /*
+    addToPortalLimit() will adjust the results of the get request so that if a layout has multiple portals in it,
+    only data from the specified ones will be read. This may help reduce load on your FileMaker API
+    */
+    addToPortalLimit(portal: Portal<any>, offset = 0, limit = 100) {
+        if (offset < 0) throw "Portal offset cannot be less than 0"
+        this.limitPortals.push({portal, offset, limit})
+        return this
+    }
+
+    setLimit(limit: number) {
+        if (limit < 1) throw "Record limit too low"
+        this.limit = limit
+        return this
+    }
+
+    addSort(fieldName, sortOrder) {
+        this.sort.push({fieldName, sortOrder})
+        return this
+    }
+
+    setOffset(offset: number) {
+        if (offset < 0) throw "Record offset too low"
+        this.limit = offset
+        return this
+    }
+}

package/src/records/getOperations/recordGetRange.d.ts

@@ -0,0 +1,13 @@
+import { LayoutInterface } from "../../layouts/layoutInterface";
+import { RecordGetOperation } from "./recordGetOperation";
+import { LayoutRecord } from "../layoutRecord";
+import { extraBodyOptions } from "../../types.js";
+export declare class RecordGetRange<T extends LayoutInterface> extends RecordGetOperation<T> {
+    constructor(layout: any, start?: number, limit?: number);
+    private generateQueryParams;
+    /**
+     * @deprecated in favour of .fetch()
+     */
+    run(extraBody?: extraBodyOptions): Promise<LayoutRecord<T["fields"], T["portals"]>[]>;
+    fetch(extraBody?: extraBodyOptions): Promise<LayoutRecord<T["fields"], T["portals"]>[]>;
+}

package/src/records/getOperations/recordGetRange.js

@@ -0,0 +1,95 @@
+/*
+ * 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 { RecordGetOperation } from "./recordGetOperation";
+import { LayoutRecord } from "../layoutRecord";
+import { FMError } from "../../FMError";
+export class RecordGetRange extends RecordGetOperation {
+    constructor(layout, start = 0, limit = 100) {
+        super(layout);
+        this.setOffset(start);
+        this.setLimit(limit);
+    }
+    generateQueryParams(extraBody = {}) {
+        let params = [];
+        if (this.limit !== 100)
+            params.push("_limit=" + this.limit);
+        if (this.offset !== 0)
+            params.push("_offset=" + this.offset);
+        if (this.sort.length > 0)
+            params.push("_sort=" + encodeURI(JSON.stringify(this.sort)));
+        if (this.limitPortals.length > 0) {
+            params.push("portal=" + encodeURI(JSON.stringify(this.limitPortals.map(p => p.portal.name))));
+            for (let item of this.limitPortals) {
+                if (item.offset !== 0)
+                    params.push("_offset." + item.portal.name.replace(/[^0-9A-z]/g, "") + "=" + item.offset);
+                if (item.limit !== 100)
+                    params.push("_limit." + item.portal.name.replace(/[^0-9A-z]/g, "") + "=" + item.limit);
+            }
+        }
+        if (extraBody.scripts) {
+            if (extraBody.scripts.prerequest) {
+                params.push("script.prerequest=" + extraBody.scripts.prerequest.name);
+                if (extraBody.scripts.prerequest.parameter)
+                    params.push("script.prerequest.param=" + extraBody.scripts.prerequest.parameter);
+            }
+            if (extraBody.scripts.presort) {
+                params.push("script.presort=" + extraBody.scripts.presort.name);
+                if (extraBody.scripts.presort.parameter)
+                    params.push("script.presort.param=" + extraBody.scripts.presort.parameter);
+            }
+            if (extraBody.scripts.after) {
+                params.push("script=" + extraBody.scripts.after.name);
+                if (extraBody.scripts.after.parameter)
+                    params.push("script.param=" + extraBody.scripts.after.parameter);
+            }
+        }
+        if (params.length === 0)
+            return "";
+        return "?" + params.join("&");
+    }
+    /**
+     * @deprecated in favour of .fetch()
+     */
+    run(extraBody = {}) {
+        return this.fetch(extraBody);
+    }
+    fetch(extraBody = {}) {
+        let trace = new Error();
+        return new Promise((resolve, reject) => {
+            // console.log(this.#toObject())
+            this.layout.getLayoutMeta().then(() => {
+                return this.layout.database.apiRequest(`${this.layout.endpoint}/records${this.generateQueryParams(extraBody)}`, {
+                    method: "GET"
+                });
+            })
+                .then((res) => __awaiter(this, void 0, void 0, function* () {
+                // // console.log(res)
+                if (res.messages[0].code === "0") {
+                    // console.log("RESOLVING")
+                    if (!this.layout.metadata)
+                        yield this.layout.getLayoutMeta();
+                    let data = res.response.data.map(item => {
+                        return new LayoutRecord(this.layout, item.recordId, item.modId, item.fieldData, item.portalData);
+                    });
+                    resolve(data);
+                }
+                else {
+                    reject(new FMError(res.messages[0].code, res.status, res, trace));
+                }
+            }))
+                .catch(e => {
+                reject(e);
+            });
+        });
+    }
+}