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

package/src/models/apiResults.js

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2023. See LICENSE file for more information
+ */
+export var ApiFieldTypes;
+(function (ApiFieldTypes) {
+    ApiFieldTypes["NORMAL"] = "normal";
+    ApiFieldTypes["CALCULATION"] = "calculation";
+    ApiFieldTypes["SUMMARY"] = "summary";
+})(ApiFieldTypes || (ApiFieldTypes = {}));
+export var ApiFieldDisplayTypes;
+(function (ApiFieldDisplayTypes) {
+    ApiFieldDisplayTypes["EDIT_TEXT"] = "editText";
+    ApiFieldDisplayTypes["POPUP_LIST"] = "popupList";
+    ApiFieldDisplayTypes["CHECKBOX"] = "checkBox";
+    ApiFieldDisplayTypes["RADIO_BUTTONS"] = "radioButtons";
+    ApiFieldDisplayTypes["SELECTION_LIST"] = "selectionList";
+    ApiFieldDisplayTypes["CALENDAR"] = "calendar";
+    ApiFieldDisplayTypes["SECURE_TEXT"] = "secureText";
+})(ApiFieldDisplayTypes || (ApiFieldDisplayTypes = {}));
+export var ApiFieldResultTypes;
+(function (ApiFieldResultTypes) {
+    ApiFieldResultTypes["TEXT"] = "text";
+    ApiFieldResultTypes["NUMBER"] = "number";
+    ApiFieldResultTypes["DATE"] = "date";
+    ApiFieldResultTypes["TIME"] = "time";
+    ApiFieldResultTypes["TIMESTAMP"] = "timeStamp";
+    ApiFieldResultTypes["CONTAINER"] = "container";
+})(ApiFieldResultTypes || (ApiFieldResultTypes = {}));

package/src/models/apiResults.ts

@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2023. See LICENSE file for more information
+ */
+
+import * as stream from "stream";
+
+export enum ApiFieldTypes {
+    NORMAL = "normal",
+    CALCULATION = "calculation",
+    SUMMARY = "summary"
+}
+
+export enum ApiFieldDisplayTypes {
+    EDIT_TEXT = "editText",
+    POPUP_LIST = "popupList",
+    CHECKBOX = "checkBox",
+    RADIO_BUTTONS = "radioButtons",
+    SELECTION_LIST = "selectionList",
+    CALENDAR = "calendar",
+    SECURE_TEXT = "secureText"
+}
+
+export enum ApiFieldResultTypes {
+    TEXT = "text",
+    NUMBER = "number",
+    DATE = "date",
+    TIME = "time",
+    TIMESTAMP = "timeStamp",
+    CONTAINER = "container"
+}
+
+export interface ApiMessage {
+    code: string,
+    message: string
+}
+
+export interface ApiResults<T = unknown> {
+    response?: null | T & {scriptError? : string},
+    messages: ApiMessage[],
+    httpStatus: number
+}
+
+export interface ApiLayout {
+    name: string,
+    isFolder: boolean,
+    folderLayoutNames: string[]
+}
+
+export interface ApiLayoutMetadata {
+    fieldMetaData: ApiFieldMetadata[],
+    portalMetaData: {[key: string]: ApiFieldMetadata[]},
+    valueLists: ApiValueList[]
+}
+
+export interface ApiFieldMetadata {
+    name: string,
+    type: ApiFieldTypes,
+    displayType: ApiFieldDisplayTypes,
+    result: ApiFieldResultTypes,
+    global: boolean,
+    autoEnter: boolean,
+    fourDigitYear: boolean,
+    maxRepeat: number,
+    maxCharacters: number,
+    notEmpty: boolean,
+    numeric: boolean,
+    repetitions: number,
+    timeOfDay: boolean,
+    valueList: string
+}
+
+export interface ApiValueList {
+    name: string,
+    type: string,
+    values: {value: string, displayName: string}[]
+}
+
+export interface ApiScriptResult {
+    scriptError: string,
+    scriptResult?: string
+}
+
+export interface ApiRecordResponseObj {
+    data: ApiRowDataDef[],
+    dataInfo: ApiResultSetObj
+}
+
+export interface ApiFieldData {[key: string]: string}
+
+export interface ApiPortalData {[key: string]: ApiFieldData[]}
+
+export interface ApiResultSetObj {
+    database: string,
+    layout: string,
+    table: string,
+    totalRecordCount: number,
+    foundCount: number,
+    returnedCount: number
+}
+
+export interface ApiRowDataDef {
+    fieldData: ApiFieldData,
+    portalData: ApiPortalData,
+    modId: string,
+    recordId: string,
+    portalDataInfo: {
+        database: string,
+        table: string,
+        foundCount: number,
+        returnedCount: number
+    }[]
+}

package/src/records/field.d.ts

@@ -1,24 +1,5 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { RecordBase } from "./recordBase.js";
-import * as http from "http";
-import { ContainerBufferResult, DOWNLOAD_MODES, FieldMetaData } from "../types.js";
-export type FieldValue = string | number | Date | Container;
-export type Container = null;
-export declare class Field<T extends FieldValue> {
+import { RecordBase } from "./recordBase";
+import { FieldBase, FieldValue } from "./fieldBase";
+export declare class Field<T extends FieldValue> extends FieldBase<T> {
     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

@@ -1,180 +1,7 @@
 /*
- * Copyright (c) 2023. See LICENSE file for more information
+ * Copyright (c) 2024. 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 { RecordTypes } from "./recordBase.js";
-import fetch, { File, FormData } from "node-fetch";
-import { DOWNLOAD_MODES } from "../types.js";
-import { FMError } from "../FMError.js";
-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.type === RecordTypes.PORTAL) {
-            // @ts-ignore
-            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",
-                // @ts-ignore
-                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) => {
-            // @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);
-            });
-        });
-    }
+import { FieldBase } from "./fieldBase";
+export class Field extends FieldBase {
+    record;
 }

package/src/records/field.ts

@@ -1,193 +1,10 @@
 /*
- * Copyright (c) 2023. See LICENSE file for more information
+ * Copyright (c) 2024. See LICENSE file for more information
  */
 
-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 {FMError} from "../FMError.js";
+import {RecordBase} from "./recordBase";
+import {FieldBase, FieldValue} from "./fieldBase";
 
-export type FieldValue = string | number | Date | Container
-export type Container = null
-
-export class Field<T extends FieldValue> {
+export class Field<T extends FieldValue> extends FieldBase<T> {
     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.type === RecordTypes.PORTAL) {
-            // @ts-ignore
-            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",
-                // @ts-ignore
-                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) => {
-            // @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
-                        } as ContainerBufferResult)
-                    })
-                })
-                .catch(e => {
-                    reject(e)
-                })
-        })
-    }
 }

package/src/records/fieldBase.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import * as http from "http";
+import { ContainerBufferResult, DOWNLOAD_MODES, RecordTypes } from "../types.js";
+import { ApiFieldMetadata } 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 declare class FieldBase<T extends FieldValue> {
+    parent: Parentable;
+    id: string;
+    protected _value: T;
+    edited: boolean;
+    constructor(record: Parentable, id: string, contents: T);
+    set(content: string | number | Date | undefined | null): void;
+    get metadata(): ApiFieldMetadata;
+    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>;
+}