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

package/src/layouts/layout.d.ts

@@ -0,0 +1,29 @@
+import { LayoutRecordManager } from "./layoutRecordManager";
+import { LayoutRecord } from "../records/layoutRecord";
+import { ScriptResult } from "../types.js";
+import { LayoutInterface } from "./layoutInterface";
+import { Find } from "../records/getOperations/find";
+import { FMError } from "../FMError";
+import { Database } from "../connection/database";
+export declare class Layout<T extends LayoutInterface> {
+    readonly database: Database;
+    readonly records: LayoutRecordManager<T>;
+    protected name: string;
+    metadata: any;
+    constructor(database: Database, name: string);
+    get endpoint(): string;
+    /**
+     * @deprecated use layout.records.create() instead
+     */
+    createRecord(): Promise<LayoutRecord<T["fields"], T["portals"]>>;
+    /**
+     * @deprecated use layout.records.get() instead
+     */
+    getRecord(recordId: any): Promise<LayoutRecord<T["fields"], T["portals"]>>;
+    /**
+     * @deprecated use layout.records.find() instead
+     */
+    newFind(): Find<T>;
+    runScript(script: any): Promise<ScriptResult>;
+    getLayoutMeta(): Promise<this | FMError>;
+}

package/src/layouts/layout.js

@@ -0,0 +1,84 @@
+/*
+ * 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 { LayoutRecordManager } from "./layoutRecordManager";
+import { FMError } from "../FMError";
+export class Layout {
+    constructor(database, name) {
+        this.records = new LayoutRecordManager(this);
+        this.database = database;
+        this.name = name;
+    }
+    get endpoint() {
+        return `${this.database.endpoint}/layouts/${this.name}`;
+    }
+    /**
+     * @deprecated use layout.records.create() instead
+     */
+    createRecord() {
+        return this.records.create();
+    }
+    /**
+     * @deprecated use layout.records.get() instead
+     */
+    getRecord(recordId) {
+        return this.records.get(recordId);
+    }
+    /**
+     * @deprecated use layout.records.find() instead
+     */
+    newFind() {
+        return this.records.find();
+    }
+    runScript(script) {
+        let trace = new Error();
+        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+            let url = `${this.endpoint}/script/${encodeURIComponent(script.name)}`;
+            if (script.parameter)
+                url += "?script.param=" + encodeURIComponent(script.parameter);
+            this.database.apiRequest(url, {
+                port: 443,
+                method: "GET"
+            })
+                .then(res => {
+                if (res.messages[0].code === "0") {
+                    let error = parseInt(res.response.scriptError);
+                    let msg = {
+                        scriptError: error ? new FMError(error, 200, res, trace) : undefined,
+                        scriptResult: res.response.scriptResult
+                    };
+                    resolve(msg);
+                }
+                else {
+                    // console.log(res)
+                    reject(new FMError(res.messages[0].code, res.status, res, trace));
+                }
+            })
+                .catch(e => {
+                reject(e);
+            });
+        }));
+    }
+    getLayoutMeta() {
+        return new Promise((resolve, reject) => {
+            if (this.metadata) {
+                resolve(this.metadata);
+                return;
+            }
+            this.database.apiRequest(this.endpoint).then(res => {
+                this.metadata = res.response;
+                resolve(this);
+            })
+                .catch(e => reject(e));
+        });
+    }
+}

package/src/layouts/layout.ts

@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2023. See LICENSE file for more information
+ */
+
+import {LayoutRecordManager} from "./layoutRecordManager";
+import {LayoutRecord} from "../records/layoutRecord";
+import {ScriptResult} from "../types.js";
+import {LayoutInterface} from "./layoutInterface";
+import {Find} from "../records/getOperations/find";
+import {FMError} from "../FMError";
+import {Database} from "../connection/database";
+
+export class Layout<T extends LayoutInterface> {
+    readonly database: Database;
+    readonly records = new LayoutRecordManager<T>(this)
+    protected name: string;
+    metadata: any;
+
+    constructor(database: Database, name: string) {
+        this.database = database
+        this.name = name
+    }
+
+    get endpoint() {
+        return `${this.database.endpoint}/layouts/${this.name}`
+    }
+
+    /**
+     * @deprecated use layout.records.create() instead
+     */
+    createRecord(): Promise<LayoutRecord<T["fields"], T["portals"]>> {
+        return this.records.create()
+    }
+
+    /**
+     * @deprecated use layout.records.get() instead
+     */
+    getRecord(recordId): Promise<LayoutRecord<T["fields"], T["portals"]>> {
+        return this.records.get(recordId)
+    }
+
+    /**
+     * @deprecated use layout.records.find() instead
+     */
+    newFind(): Find<T> {
+        return this.records.find()
+    }
+
+    runScript(script): Promise<ScriptResult> {
+        let trace = new Error()
+        return new Promise(async (resolve, reject) => {
+            let url = `${this.endpoint}/script/${encodeURIComponent(script.name)}`
+            if (script.parameter) url += "?script.param=" + encodeURIComponent(script.parameter)
+            this.database.apiRequest(url, {
+                port: 443,
+                method: "GET"
+            })
+                .then(res => {
+                    if (res.messages[0].code === "0") {
+                        let error = parseInt(res.response.scriptError)
+                        let msg: ScriptResult = {
+                            scriptError: error ? new FMError(error, 200, res, trace) : undefined,
+                            scriptResult: res.response.scriptResult
+                        }
+                        resolve(msg)
+                    }
+                    else {
+                        // console.log(res)
+                        reject(new FMError(res.messages[0].code, res.status, res, trace))
+                    }
+                })
+                .catch(e => {
+                    reject(e)
+                })
+        })
+    }
+
+    public getLayoutMeta(): Promise<this | FMError> {
+        return new Promise((resolve, reject) => {
+            if (this.metadata) {
+                resolve(this.metadata)
+                return
+            }
+
+            this.database.apiRequest(this.endpoint).then(res => {
+                this.metadata = res.response
+                resolve(this)
+            })
+                .catch(e => reject(e))
+        })
+    }
+}

package/src/layouts/layoutInterface.d.ts

@@ -0,0 +1,13 @@
+import { Portal } from "../records/portal";
+import { Field } from "../records/field";
+export interface LayoutInterface {
+    fields: RecordFieldsMap;
+    portals: PortalInterface;
+}
+export interface PortalInterface {
+    [key: string]: Portal<RecordFieldsMap>;
+}
+export interface RecordFieldsMap {
+    [fieldName: string]: Field<FieldValue>;
+}
+export type FieldValue = string | number | Date;

package/src/layouts/layoutInterface.js

@@ -0,0 +1,4 @@
+/*
+ * Copyright (c) 2023. See LICENSE file for more information
+ */
+export {};

package/src/layouts/layoutInterface.ts

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2023. See LICENSE file for more information
+ */
+
+import {Portal} from "../records/portal";
+import {Field} from "../records/field";
+
+export interface LayoutInterface {
+    fields: RecordFieldsMap,
+    portals: PortalInterface
+}
+
+export interface PortalInterface {
+    [key: string]: Portal<RecordFieldsMap>
+}
+
+export interface RecordFieldsMap {
+    [fieldName: string]: Field<FieldValue>
+}
+
+export type FieldValue = string | number | Date

package/src/layouts/layoutRecordManager.d.ts

@@ -0,0 +1,13 @@
+import { LayoutRecord } from "../records/layoutRecord";
+import { Layout } from "./layout";
+import { LayoutInterface } from "./layoutInterface";
+import { RecordGetRange } from "../records/getOperations/recordGetRange";
+import { Find } from "../records/getOperations/find";
+export declare class LayoutRecordManager<T extends LayoutInterface> {
+    readonly layout: Layout<T>;
+    constructor(layout: Layout<T>);
+    create(): Promise<LayoutRecord<T["fields"], T["portals"]>>;
+    get(recordId: any): Promise<LayoutRecord<T["fields"], T["portals"]>>;
+    range(start?: number, limit?: number): RecordGetRange<LayoutInterface>;
+    find(start?: number, limit?: number): Find<T>;
+}

package/src/layouts/layoutRecordManager.js

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2023. See LICENSE file for more information
+ */
+import { LayoutRecord } from "../records/layoutRecord";
+import { RecordGetRange } from "../records/getOperations/recordGetRange";
+import { Find } from "../records/getOperations/find";
+export class LayoutRecordManager {
+    constructor(layout) {
+        this.layout = layout;
+    }
+    create() {
+        return new Promise((resolve, reject) => {
+            // Get the layout's metadata
+            this.layout.getLayoutMeta().then(layout => {
+                let fields = {};
+                for (let _field of this.layout.metadata.fieldMetaData) {
+                    fields[_field.name] = "";
+                }
+                let portals = {};
+                for (let _portal of Object.keys(this.layout.metadata.portalMetaData))
+                    portals[_portal] = [];
+                resolve(new LayoutRecord(this.layout, -1, 0, fields, portals));
+            }).catch(e => {
+                reject(e);
+            });
+        });
+    }
+    get(recordId) {
+        return new Promise((resolve, reject) => {
+            let record;
+            this.layout.getLayoutMeta()
+                .then(layout => {
+                record = new LayoutRecord(this.layout, recordId);
+                return record.get();
+            })
+                .then(() => {
+                resolve(record);
+            })
+                .catch(e => {
+                reject(e);
+            });
+        });
+    }
+    range(start = 0, limit = 100) {
+        return new RecordGetRange(this.layout, start, limit);
+    }
+    find(start = 0, limit = 100) {
+        return new Find(this.layout, start, limit);
+    }
+}

package/src/layouts/layoutRecordManager.ts

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2023. See LICENSE file for more information
+ */
+
+import {LayoutRecord} from "../records/layoutRecord";
+import {Layout} from "./layout";
+import {LayoutInterface} from "./layoutInterface";
+import {RecordGetRange} from "../records/getOperations/recordGetRange";
+import {Find} from "../records/getOperations/find";
+
+export class LayoutRecordManager<T extends LayoutInterface> {
+    readonly layout: Layout<T>
+
+    constructor(layout: Layout<T>) {
+        this.layout = layout
+    }
+
+    create(): Promise<LayoutRecord<T["fields"], T["portals"]>> {
+        return new Promise((resolve, reject) => {
+            // Get the layout's metadata
+            this.layout.getLayoutMeta().then(layout => {
+                let fields = {}
+                for (let _field of this.layout.metadata.fieldMetaData) {
+                    fields[_field.name] = ""
+                }
+                let portals = {}
+                for (let _portal of Object.keys(this.layout.metadata.portalMetaData)) portals[_portal] = []
+                resolve(new LayoutRecord(this.layout, -1, 0, fields, portals))
+            }).catch(e => {
+                reject(e)
+            })
+        })
+    }
+
+    get(recordId): Promise<LayoutRecord<T["fields"], T["portals"]>> {
+        return new Promise((resolve, reject) => {
+            let record
+            this.layout.getLayoutMeta()
+                .then(layout => {
+                    record = new LayoutRecord(this.layout, recordId)
+                    return record.get()
+                })
+                .then(() => {
+                    resolve(record)
+                })
+                .catch(e => {
+                    reject(e)
+                })
+        })
+    }
+
+    range(start = 0, limit = 100) {
+        return new RecordGetRange(this.layout, start, limit)
+    }
+
+    find(start = 0, limit = 100): Find<T> {
+        return new Find(this.layout, start, limit)
+    }
+}

package/src/records/field.d.ts

@@ -0,0 +1,21 @@
+import { RecordBase } from "./recordBase";
+import * as http from "http";
+import { ContainerBufferResult, DOWNLOAD_MODES, FieldMetaData } from "../types.js";
+import { FieldValue } from "../layouts/layoutInterface";
+export declare class Field<T extends FieldValue> {
+    record: RecordBase<any>;
+    id: string;
+    protected _value: T;
+    edited: boolean;
+    constructor(record: any, id: any, contents: any);
+    set(content: string | number | Date | undefined | null): void;
+    get metadata(): FieldMetaData;
+    get value(): T;
+    set value(value: T);
+    get string(): string;
+    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>;
+}

package/src/records/field.js

@@ -0,0 +1,177 @@
+/*
+ * 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 fetch, { File, FormData } from "node-fetch";
+import { DOWNLOAD_MODES } from "../types.js";
+import { PortalRecord } from "./portalRecord";
+import { FMError } from "../FMError";
+export class Field {
+    constructor(record, id, contents) {
+        this.record = 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.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
+            };
+        }
+        if (this.record instanceof PortalRecord) {
+            return this.record.layout.metadata.portalMetaData[this.record.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.record.layout.metadata.fieldMetaData.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
+            };
+        }
+    }
+    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";
+    }
+    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)";
+        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+            let form = new FormData();
+            form.append("upload", new File([buffer], filename, { type: mime }));
+            let _fetch = yield 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;
+                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) {
+        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
+                    });
+                });
+            })
+                .catch(e => {
+                reject(e);
+            });
+        });
+    }
+}