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

package/src/records/fieldBase.js

@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) 2023-2024. See LICENSE file for more information
+ */
+import { DOWNLOAD_MODES, RecordTypes } from "../types.js";
+import { ApiFieldDisplayTypes, ApiFieldResultTypes, ApiFieldTypes } from "../models/apiResults.js";
+export class FieldBase {
+    parent;
+    id;
+    _value;
+    edited;
+    constructor(record, id, contents) {
+        this.parent = record;
+        this.id = id;
+        this._value = contents;
+        this.edited = false;
+    }
+    set(content) {
+        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() {
+        if (!this.parent.layout.metadata) {
+            // Default to a regular text field
+            return {
+                name: this.id.toString(),
+                type: ApiFieldTypes.NORMAL,
+                displayType: ApiFieldDisplayTypes.EDIT_TEXT,
+                result: ApiFieldResultTypes.TEXT,
+                global: false,
+                autoEnter: true,
+                fourDigitYear: false,
+                maxRepeat: 1,
+                maxCharacters: 0,
+                notEmpty: false,
+                numeric: false,
+                timeOfDay: false,
+                repetitions: 1,
+                valueList: ""
+            };
+        }
+        if (this.parent.type === RecordTypes.PORTAL) {
+            // @ts-ignore
+            return this.parent.layout.metadata.portalMetaData[this.parent.portal.name || "portal not attached"].find(i => i.name === this.id) || {
+                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
+            };
+        }
+        else {
+            return this.parent.layout.metadata.fieldMetaData.find(i => i.name === this.id) || {
+                name: this.id.toString(),
+                type: ApiFieldTypes.NORMAL,
+                displayType: ApiFieldDisplayTypes.EDIT_TEXT,
+                result: ApiFieldResultTypes.TEXT,
+                global: false,
+                autoEnter: true,
+                fourDigitYear: false,
+                maxRepeat: 1,
+                maxCharacters: 0,
+                notEmpty: false,
+                numeric: false,
+                timeOfDay: false,
+                repetitions: 1,
+                valueList: ""
+            };
+        }
+    }
+    get value() {
+        // 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) {
+        this._value = value;
+    }
+    get string() {
+        if (typeof this._value === "string") {
+            return this._value;
+        }
+        throw "Field value is not a string";
+    }
+    get date() {
+        if (this._value instanceof Date) {
+            return this._value;
+        }
+        throw "Field value is not a date";
+    }
+    get number() {
+        if (typeof this._value === "number") {
+            return this._value;
+        }
+        throw "Field value is not a number";
+    }
+    async upload(buffer, filename, mime) {
+        let trace = new Error();
+        if (this.metadata.result !== "container")
+            throw "Cannot upload a file to the field; " + this.id + " (not a container field)";
+        let form = new FormData();
+        form.append("upload", new File([buffer], filename, { type: mime }));
+        await this.parent.layout.database.apiRequest(`${this.parent.endpoint}/containers/${this.id}/1`, {
+            method: "POST",
+            // @ts-ignore
+            headers: { "Authorization": "Bearer " + this.parent.layout.database.token },
+            body: form
+        });
+    }
+    async download(mode = DOWNLOAD_MODES.Stream) {
+        if (this.metadata.result !== ApiFieldResultTypes.CONTAINER)
+            throw new Error("Cannot perform download() on a non-container field");
+        let stream = await this.parent.layout.database.streamURL(this.string);
+        if (mode === DOWNLOAD_MODES.Stream) {
+            return stream;
+        }
+        let body = [];
+        return new Promise((resolve, reject) => {
+            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
+                });
+            });
+        });
+    }
+}

package/src/records/fieldBase.ts

@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) 2023-2024. See LICENSE file for more information
+ */
+
+import * as http from "http";
+import {ContainerBufferResult, DOWNLOAD_MODES, FieldMetaData, RecordTypes} from "../types.js";
+import {ApiFieldDisplayTypes, ApiFieldMetadata, ApiFieldResultTypes, ApiFieldTypes} from "../models/apiResults.js";
+import {LayoutBase} from "../layouts/layoutBase.js";
+
+export type FieldValue = string | number | Date | Container
+export type Container = null
+
+export type Parentable = {layout: LayoutBase, type: RecordTypes, endpoint: string}
+export class FieldBase<T extends FieldValue> {
+    parent: Parentable;
+    id: string;
+    protected _value: T;
+    edited: boolean;
+
+    constructor(record: Parentable, id: string, contents: T) {
+        this.parent = 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(): ApiFieldMetadata {
+        if (!this.parent.layout.metadata) {
+            // Default to a regular text field
+            return {
+                name: this.id.toString(),
+                type: ApiFieldTypes.NORMAL,
+                displayType: ApiFieldDisplayTypes.EDIT_TEXT,
+                result: ApiFieldResultTypes.TEXT,
+                global: false,
+                autoEnter: true,
+                fourDigitYear: false,
+                maxRepeat: 1,
+                maxCharacters: 0,
+                notEmpty: false,
+                numeric: false,
+                timeOfDay: false,
+                repetitions: 1,
+                valueList: ""
+            }
+        }
+        if (this.parent.type === RecordTypes.PORTAL) {
+            // @ts-ignore
+            return this.parent.layout.metadata.portalMetaData[this.parent.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.parent.layout.metadata.fieldMetaData.find(i => i.name === this.id) || {
+                name: this.id.toString(),
+                type: ApiFieldTypes.NORMAL,
+                displayType: ApiFieldDisplayTypes.EDIT_TEXT,
+                result: ApiFieldResultTypes.TEXT,
+                global: false,
+                autoEnter: true,
+                fourDigitYear: false,
+                maxRepeat: 1,
+                maxCharacters: 0,
+                notEmpty: false,
+                numeric: false,
+                timeOfDay: false,
+                repetitions: 1,
+                valueList: ""
+            }
+        }
+    }
+
+    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"
+    }
+
+    async 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)"
+        let form = new FormData()
+        form.append("upload", new File([buffer], filename, {type: mime}))
+
+        await this.parent.layout.database.apiRequest<null>(`${this.parent.endpoint}/containers/${this.id}/1`, {
+            method: "POST",
+            // @ts-ignore
+            headers: {"Authorization": "Bearer " + this.parent.layout.database.token},
+            body: form
+        })
+    }
+
+    download(mode: DOWNLOAD_MODES.Stream): Promise<http.IncomingMessage>
+    download(mode: DOWNLOAD_MODES.Buffer): Promise<ContainerBufferResult>
+    async download(mode: DOWNLOAD_MODES = DOWNLOAD_MODES.Stream): Promise<http.IncomingMessage | ContainerBufferResult> {
+        if (this.metadata.result !== ApiFieldResultTypes.CONTAINER) throw new Error("Cannot perform download() on a non-container field")
+
+        let stream = await this.parent.layout.database.streamURL(this.string)
+        if (mode === DOWNLOAD_MODES.Stream) {
+            return stream
+        }
+
+        let body = []
+        return new Promise((resolve, reject) => {
+            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)
+            })
+        })
+    }
+}

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

@@ -1,17 +1,53 @@
 import { LayoutInterface } from "../../layouts/layoutInterface.js";
-import { Portal } from "../portal.js";
-import { limitPortalsInterface } from "../../types.js";
+import { ScriptRequestData } from "../../types.js";
 import { LayoutBase } from "../../layouts/layoutBase.js";
-export declare class RecordGetOperation<T extends LayoutInterface> {
+import { LayoutRecord } from "../layoutRecord.js";
+export type SortOrder = "ascend" | "descend";
+export type FindRequest = {
+    [key: string]: string;
+    omit?: "true" | "false";
+};
+export type PortalRequest = {
+    name: string;
+};
+type PortalData<T extends LayoutInterface> = {
+    [key in keyof T["portals"]]: {
+        limit: number;
+        offset: number;
+    };
+};
+export type GetOperationOptions<T extends LayoutInterface> = {
+    portals: Partial<PortalData<T>>;
+    limit?: number;
+    offset?: number;
+};
+export declare class RecordGetOperation<T extends LayoutInterface, OPTIONS extends GetOperationOptions<T>> {
     protected layout: LayoutBase;
     protected limit: number;
-    protected scripts: object;
-    protected sort: object[];
-    protected limitPortals: limitPortalsInterface[];
+    protected scriptData: ScriptRequestData;
+    protected sortData: {
+        fieldName: string;
+        sortOrder: SortOrder;
+    }[];
+    protected portals: Partial<PortalData<T>>;
     protected offset: number;
-    constructor(layout: LayoutBase);
-    addToPortalLimit(portal: Portal<any>, offset?: number, limit?: number): this;
-    setLimit(limit: number): this;
-    addSort(fieldName: any, sortOrder: any): this;
-    setOffset(offset: number): this;
+    protected queries: FindRequest[];
+    constructor(layout: LayoutBase, options: OPTIONS);
+    get isFindRequest(): boolean;
+    protected generateParamsBody(offset: number, limit: number): {
+        [key: string]: any;
+    };
+    protected generateParamsURL(offset: number, limit: number): URLSearchParams;
+    scripts(scripts: ScriptRequestData): this;
+    sort(fieldName: string, sortOrder: SortOrder): this;
+    addRequest(query: FindRequest): this;
+    fetch(): Promise<LayoutRecord<T, keyof OPTIONS["portals"]>[]>;
+    private performFind;
+    [Symbol.asyncIterator](): {
+        next: () => Promise<{
+            done: boolean;
+            value: LayoutRecord<T, keyof OPTIONS["portals"]>;
+        }>;
+    };
 }
+export {};

package/src/records/getOperations/recordGetOperation.js

@@ -1,46 +1,157 @@
 /*
- * Copyright (c) 2023. See LICENSE file for more information
+ * Copyright (c) 2023-2024. See LICENSE file for more information
  */
+import { LayoutRecord } from "../layoutRecord.js";
+import { FMError } from "../../FMError.js";
 export class RecordGetOperation {
     layout;
     limit = 100;
-    scripts;
-    sort;
-    limitPortals = [];
-    offset = 0;
-    constructor(layout) {
+    scriptData = {};
+    sortData = [];
+    portals;
+    offset = 1;
+    queries = [];
+    constructor(layout, options) {
         this.layout = layout;
-        this.scripts = {
-            "script": null,
-            "script.prerequeset": null,
-            "script.presort": null // Runs before the sort
+        this.sortData = [];
+        this.portals = options.portals;
+        this.offset = options.offset || 1; // Offset refers to the starting record. offset 1 is the same as no offset.
+        this.limit = options.limit || 100;
+    }
+    get isFindRequest() {
+        return this.queries.length !== 0;
+    }
+    generateParamsBody(offset, limit) {
+        const params = {
+            limit: limit.toString(),
+            offset: offset.toString(),
         };
-        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({ portalName: portal.name, offset, limit });
-        return this;
+        if (this.sortData.length !== 0)
+            params.sort = JSON.stringify(this.sortData);
+        if (this.scriptData.after)
+            params["script"] = this.scriptData.after.name;
+        if (this.scriptData.after?.parameter)
+            params["script.param"] = this.scriptData.after.parameter;
+        if (this.scriptData.presort)
+            params["script.presort"] = this.scriptData.after.name;
+        if (this.scriptData.presort?.parameter)
+            params["script.presort.param"] = this.scriptData.after.parameter;
+        if (this.scriptData.prerequest)
+            params["script.prerequest"] = this.scriptData.after.name;
+        if (this.scriptData.prerequest?.parameter)
+            params["script.prerequest.param"] = this.scriptData.after.parameter;
+        if (this.queries.length !== 0)
+            params["query"] = this.queries;
+        let portals = Object.keys(this.portals);
+        params["portal"] = portals;
+        for (let portal of portals) {
+            params[`offset.${portal}`] = this.portals[portal].offset;
+            params[`limit.${portal}`] = this.portals[portal].limit;
+        }
+        return params;
     }
-    setLimit(limit) {
-        if (limit < 1)
-            throw "Record limit too low";
-        this.limit = limit;
+    generateParamsURL(offset, limit) {
+        const params = new URLSearchParams({
+            _limit: limit.toString(),
+            _offset: offset.toString(),
+        });
+        if (this.sortData.length !== 0)
+            params.set("_sort", JSON.stringify(this.sortData));
+        if (this.scriptData.after)
+            params.set("script", this.scriptData.after.name);
+        if (this.scriptData.after?.parameter)
+            params.set("script.param", this.scriptData.after.parameter);
+        if (this.scriptData.presort)
+            params.set("script.presort", this.scriptData.after.name);
+        if (this.scriptData.presort?.parameter)
+            params.set("script.presort.param", this.scriptData.after.parameter);
+        if (this.scriptData.prerequest)
+            params.set("script.prerequest", this.scriptData.after.name);
+        if (this.scriptData.prerequest?.parameter)
+            params.set("script.prerequest.param", this.scriptData.after.parameter);
+        let portals = Object.keys(this.portals);
+        for (let portal of portals) {
+            params.set(`_offset.${portal}`, this.portals[portal].limit.toString());
+            params.set(`_offset.${portal}`, this.portals[portal].offset.toString());
+        }
+        params.set('portal', JSON.stringify(portals));
+        return params;
+    }
+    scripts(scripts) {
+        this.scriptData = scripts;
         return this;
     }
-    addSort(fieldName, sortOrder) {
-        this.sort.push({ fieldName, sortOrder });
+    sort(fieldName, sortOrder) {
+        this.sortData.push({ fieldName, sortOrder });
         return this;
     }
-    setOffset(offset) {
-        if (offset < 0)
-            throw "Record offset too low";
-        this.offset = offset;
+    addRequest(query) {
+        this.queries.push(query);
         return this;
     }
+    fetch() {
+        return this.performFind(this.offset, this.limit);
+    }
+    async performFind(offset, limit) {
+        let trace = new Error();
+        await this.layout.getLayoutMeta();
+        const is_find = this.isFindRequest;
+        let endpoint = this.layout.endpoint + (is_find ? "/_find" : "/records");
+        if (!is_find)
+            endpoint += "?" + new URLSearchParams(this.generateParamsURL(offset, limit)).toString();
+        const reqData = {
+            // port: 443,
+            method: is_find ? "POST" : "GET",
+            body: is_find ? JSON.stringify(this.generateParamsBody(offset, limit)) : undefined,
+        };
+        let res = await this.layout.database.apiRequest(endpoint, reqData);
+        if (res.messages[0].code === "0") {
+            // console.log("RESOLVING")
+            if (!this.layout.metadata)
+                await this.layout.getLayoutMeta();
+            return res.response.data.map(item => {
+                return new LayoutRecord(this.layout, item.recordId, item.modId, item.fieldData, item.portalData);
+            });
+        }
+        else if (res.messages[0].code == "401") {
+            // No records found, so return empty set
+            return [];
+        }
+        else {
+            throw new FMError(res.messages[0].code, res.httpStatus, res, trace);
+        }
+    }
+    [Symbol.asyncIterator]() {
+        let nextOffset = this.offset;
+        let startOffset = JSON.parse(JSON.stringify(this.offset));
+        let limit = this.limit;
+        let exit_after_last_record = false;
+        let records = [];
+        const fetch = async () => {
+            const theoretical_limit = (limit - nextOffset) + startOffset;
+            if (theoretical_limit === 0) {
+                exit_after_last_record = true;
+                records = [];
+                return;
+            }
+            records = await this.performFind(nextOffset, theoretical_limit < 100 ? theoretical_limit : 100);
+            nextOffset += 100;
+            if (records.length < 100)
+                exit_after_last_record = true;
+        };
+        return {
+            next: async () => {
+                if (records.length === 0 && !exit_after_last_record) {
+                    await fetch();
+                }
+                if (records.length === 0 && exit_after_last_record) {
+                    return { done: true, value: undefined };
+                }
+                else {
+                    const record = records.shift();
+                    return { done: false, value: record };
+                }
+            }
+        };
+    }
 }