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

package/src/records/field.ts

@@ -1,175 +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 {ApiFieldDisplayTypes, ApiFieldMetadata, ApiFieldResultTypes, ApiFieldTypes} from "../models/apiResults.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(): ApiFieldMetadata {
-        if (!this.record.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.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) || {
-                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.record.layout.database.apiRequest<null>(`${this.record.endpoint}/containers/${this.id}/1`, {
-            method: "POST",
-            // @ts-ignore
-            headers: {"Authorization": "Bearer " + this.record.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.record.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/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>;
+}

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: Uint8Array[] = []
+        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 {};