@jd-data-limited/easy-fm 4.0.11 → 4.0.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jd-data-limited/easy-fm",
-  "version": "4.0.11",
+  "version": "4.0.12",
   "dependencies": {
     "follow-redirects": "^1.15.5",
     "@types/follow-redirects": "^1.14.4",

package/src/bin/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/src/bin/cli.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+/*
+ * Copyright (c) 2024. See LICENSE file for more information
+ */
+import { Command } from "commander";
+import { generateTypesCLI } from "./generateTypes.js";
+const program = new Command();
+program
+    .name("easyfm")
+    .description("A NodeJS wrapper for the FileMaker Data CLI");
+program
+    .command("generate-types")
+    .description("Automatically generate layout interfaces from your database")
+    .action(() => {
+    generateTypesCLI();
+});
+program.parse(process.argv);

package/src/bin/generateTypes.d.ts

@@ -0,0 +1 @@
+export declare function generateTypesCLI(): Promise<void>;

package/src/bin/generateTypes.js

@@ -0,0 +1,161 @@
+/*
+ * Copyright (c) 2024. See LICENSE file for more information
+ */
+import { ApiFieldResultTypes } from "../models/apiResults.js";
+import inquirer from 'inquirer';
+import FMHost from "../connection/FMHost.js";
+import * as fs from "fs";
+function sub(str) {
+    return str
+        .replace(/[^a-zA-Z0-9_]/g, "") // Remove non-alphanumeric characters
+        .replace(/^[0-9]+/g, ''); // Removing leading numbers
+}
+function generateFieldType(field) {
+    switch (field.result) {
+        case ApiFieldResultTypes.TEXT:
+            return "Field<string>";
+        case ApiFieldResultTypes.CONTAINER:
+            return "Field<Container>";
+        case ApiFieldResultTypes.DATE:
+            return "Field<Date>";
+        case ApiFieldResultTypes.NUMBER:
+            return "Field<number>";
+        case ApiFieldResultTypes.TIME:
+            return "Field<Date>";
+        case ApiFieldResultTypes.TIMESTAMP:
+            return "Field<Date>";
+    }
+}
+function processFieldsChunk(fields) {
+    let existing_fields = [];
+    fields = fields.filter(field => {
+        if (existing_fields.includes(field.name))
+            return false;
+        existing_fields.push(field.name);
+        return true;
+    });
+    return fields.map(field => {
+        return JSON.stringify(field.name) + ": " + generateFieldType(field);
+    });
+}
+function camelToSnakeCase(str) {
+    return str.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toLowerCase();
+}
+function safeStringInjection(str, ...args) {
+    let result = "";
+    for (let i = 0; i < str.length; i++) {
+        result += str[i];
+        if (i < args.length) {
+            result += JSON.stringify(args[i].toString());
+        }
+    }
+    return result;
+}
+export async function generateTypesCLI() {
+    process.stdout.write('\x1Bc');
+    console.log("For this tool to work, you are required to have access to an account on the target database.\n" +
+        "This account must have the fmrest extended privilege enabled.\n" +
+        "This tool can only export type interfaces for layouts that the given account has access to.");
+    console.log("\n");
+    const data = await inquirer.prompt([
+        {
+            type: "input",
+            name: "hostname",
+            message: "The IP address/domain of your FileMaker server (must start with either http:// or https://)",
+            validate(input) {
+                return input.startsWith("http://") || input.startsWith("https://") || "Please enter a valid IP address/domain starting with http:// or https://";
+            }
+        },
+        {
+            type: "number",
+            name: "timezoneOffset",
+            message: "Server timezone offset (minutes)",
+            default: 0 - (new Date()).getTimezoneOffset()
+        },
+        {
+            type: "confirm",
+            name: "verify",
+            default: true,
+            message: "Verify your server's identity",
+            when(previousAnswers) {
+                return previousAnswers.hostname.startsWith("https://");
+            }
+        },
+        {
+            type: "input",
+            name: "database",
+            message: "Database filename"
+        },
+        {
+            type: "input",
+            name: "username",
+            message: "Database username"
+        },
+        {
+            type: "password",
+            name: "password",
+            message: "Database password",
+            mask: "*"
+        }
+    ]);
+    const HOST = new FMHost(data.hostname, data.timezoneOffset, data.verify);
+    const DATABASE = HOST.database({
+        database: data.database,
+        credentials: {
+            method: "filemaker",
+            username: data.username,
+            password: data.password
+        },
+        externalSources: []
+    });
+    await DATABASE.login();
+    // Create file write stream
+    const stream = fs.createWriteStream("./types.ts");
+    let layouts = await DATABASE.listLayouts();
+    stream.write(`import FMHost, {Container, FieldBase, LayoutInterface, Portal} from "@jd-data-limited/easy-fm";\n`);
+    stream.write("// " + layouts.length + " layouts found\n\n");
+    let layoutInterfaces = new Map();
+    for (let layout of layouts) {
+        let substituteName = sub(layout.name);
+        if (!substituteName)
+            continue;
+        console.log(substituteName);
+        let metadata = await layout.getLayoutMeta();
+        let fields = processFieldsChunk(metadata.fieldMetaData);
+        let portals = metadata.portalMetaData;
+        let portalsProcessed = Object.keys(portals).map(portalName => {
+            return `${JSON.stringify(portalName)}: Portal<{${processFieldsChunk(portals[portalName])}}>`;
+        });
+        let interfaceName = substituteName + "LayoutInterface";
+        layoutInterfaces.set(layout.name, {
+            interfaceName,
+            interface: `export interface ${interfaceName} extends LayoutInterface {
+            fields: {${fields.join(",\n    ")}},
+            portals: {${portalsProcessed.join(",\n   ")}}
+        }`
+        });
+    }
+    let layoutInterfaceLinks = [];
+    for (let layout of layoutInterfaces) {
+        layoutInterfaceLinks.push([
+            `${JSON.stringify(layout[0])}: ${layout[1].interfaceName}`,
+            `${sub(camelToSnakeCase(layout[0]).toUpperCase().replace(" ", "_"))}: HOST.getLayout<${layout[1].interfaceName}>(${JSON.stringify(layout[0])})`
+        ]);
+    }
+    stream.write(safeStringInjection `const HOST = new FMHost(${data.hostname}, ${data.timezoneOffset}, ${data.verify});`);
+    stream.write(`HOST.database<{layouts:{${layoutInterfaceLinks.map(i => i[0]).join(",")}}}>();`);
+    stream.write("\n\n");
+    stream.write(`const LAYOUTS = {${layoutInterfaceLinks.map(i => i[1]).join(",")}};`);
+    for (let layout of layoutInterfaces) {
+        stream.write("\n\n");
+        stream.write(layout[1].interface + ";");
+    }
+    // StructureKind
+    //
+    // const project = new Project({
+    //     tsConfigFilePath: "../tsconfig.json"
+    // })
+    // project.resolveSourceFileDependencies()
+    await DATABASE.logout();
+    console.log("DONE! Wrote database types to ./types.ts");
+}

package/src/bin/generateTypes.ts

@@ -16,17 +16,17 @@ function sub(str: string) {
 function generateFieldType(field: ApiFieldMetadata) {
     switch (field.result) {
         case ApiFieldResultTypes.TEXT:
-            return "FieldBase<string>"
+            return "Field<string>"
         case ApiFieldResultTypes.CONTAINER:
-            return "FieldBase<Container>"
+            return "Field<Container>"
         case ApiFieldResultTypes.DATE:
-            return "FieldBase<Date>"
+            return "Field<Date>"
         case ApiFieldResultTypes.NUMBER:
-            return "FieldBase<number>"
+            return "Field<number>"
         case ApiFieldResultTypes.TIME:
-            return "FieldBase<Date>"
+            return "Field<Date>"
         case ApiFieldResultTypes.TIMESTAMP:
-            return "FieldBase<Date>"
+            return "Field<Date>"
     }
 }
 
@@ -131,6 +131,9 @@ export async function generateTypesCLI() {
         interface: string
     }>()
     for (let layout of layouts) {
+        let substituteName = sub(layout.name)
+        if (!substituteName) continue
+        console.log(substituteName)
         let metadata = await layout.getLayoutMeta()
         let fields = processFieldsChunk(metadata.fieldMetaData)
 
@@ -141,7 +144,7 @@ export async function generateTypesCLI() {
             )}}>`
         })
 
-        let interfaceName = sub(layout.name) + "LayoutInterface"
+        let interfaceName = substituteName + "LayoutInterface"
         layoutInterfaces.set(layout.name, {
             interfaceName,
             interface: `export interface ${interfaceName} extends LayoutInterface {

package/src/index.d.ts

@@ -9,10 +9,10 @@ import { LayoutRecord } from "./records/layoutRecord.js";
 import { LayoutInterface, PortalInterface } from "./layouts/layoutInterface.js";
 import { PortalRecord } from "./records/portalRecord.js";
 import { Portal } from "./records/portal.js";
-import { Container, FieldBase } from "./records/fieldBase.js";
-import { FindRequest, RecordGetOperation } from "./records/getOperations/recordGetOperation.js";
+import { FindRequestRaw, RecordGetOperation } from "./records/getOperations/recordGetOperation.js";
 import { LayoutRecordManager } from "./layouts/layoutRecordManager.js";
 import { RecordFieldsMap } from "./layouts/recordFieldsMap.js";
 import { query, queryEscape } from "./utils/query.js";
+import { Container, Field } from "./records/field.js";
 export default FMHost;
-export { FMError, TYPES, Database, Layout, RecordBase, LayoutRecord, LayoutInterface, RecordFieldsMap, PortalInterface, PortalRecord, Portal, FieldBase, RecordGetOperation, LayoutRecordManager, Container, PickPortals, FindRequest, query, queryEscape };
+export { FMError, TYPES, Database, Layout, RecordBase, LayoutRecord, LayoutInterface, RecordFieldsMap, PortalInterface, PortalRecord, Portal, Field, RecordGetOperation, LayoutRecordManager, Container, PickPortals, FindRequestRaw, query, queryEscape };

package/src/index.js

@@ -10,9 +10,9 @@ import { RecordBase } from "./records/recordBase.js";
 import { LayoutRecord } from "./records/layoutRecord.js";
 import { PortalRecord } from "./records/portalRecord.js";
 import { Portal } from "./records/portal.js";
-import { FieldBase } from "./records/fieldBase.js";
 import { RecordGetOperation } from "./records/getOperations/recordGetOperation.js";
 import { LayoutRecordManager } from "./layouts/layoutRecordManager.js";
 import { query, queryEscape } from "./utils/query.js";
+import { Field } from "./records/field.js";
 export default FMHost;
-export { FMError, TYPES, Database, Layout, RecordBase, LayoutRecord, PortalRecord, Portal, FieldBase, RecordGetOperation, LayoutRecordManager, query, queryEscape };
+export { FMError, TYPES, Database, Layout, RecordBase, LayoutRecord, PortalRecord, Portal, Field, RecordGetOperation, LayoutRecordManager, query, queryEscape };

package/src/index.ts

@@ -13,11 +13,11 @@ import {LayoutRecord} from "./records/layoutRecord.js";
 import {LayoutInterface, PortalInterface} from "./layouts/layoutInterface.js";
 import {PortalRecord} from "./records/portalRecord.js";
 import {Portal} from "./records/portal.js";
-import {Container, FieldBase} from "./records/fieldBase.js";
-import {FindRequest, RecordGetOperation} from "./records/getOperations/recordGetOperation.js";
+import {FindRequestRaw, RecordGetOperation} from "./records/getOperations/recordGetOperation.js";
 import {LayoutRecordManager} from "./layouts/layoutRecordManager.js";
 import {RecordFieldsMap} from "./layouts/recordFieldsMap.js";
 import {query, queryEscape} from "./utils/query.js";
+import {Container, Field} from "./records/field.js";
 
 export default FMHost
 export {
@@ -32,12 +32,12 @@ export {
     PortalInterface,
     PortalRecord,
     Portal,
-    FieldBase,
+    Field,
     RecordGetOperation,
     LayoutRecordManager,
     Container,
     PickPortals,
-    FindRequest,
+    FindRequestRaw,
     query,
     queryEscape
 }

package/src/layouts/recordFieldsMap.d.ts

@@ -1,4 +1,4 @@
-import { FieldBase, FieldValue } from "../records/fieldBase.js";
+import { Field, FieldValue } from "../records/field.js";
 export interface RecordFieldsMap {
-    [fieldName: string]: FieldBase<FieldValue>;
+    [fieldName: string]: Field<FieldValue>;
 }

package/src/layouts/recordFieldsMap.ts

@@ -2,8 +2,8 @@
  * Copyright (c) 2023-2024. See LICENSE file for more information
  */
 
-import {FieldBase, FieldValue} from "../records/fieldBase.js";
+import {Field, FieldValue} from "../records/field.js";
 
 export interface RecordFieldsMap {
-    [fieldName: string]: FieldBase<FieldValue>
+    [fieldName: string]: Field<FieldValue>
 }

package/src/records/field.d.ts

@@ -1,18 +1,24 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { RecordBase } from "./recordBase.js";
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
 import * as http from "http";
-import { ContainerBufferResult, DOWNLOAD_MODES } from "../types.js";
+import { ContainerBufferResult, DownloadModes, RecordTypes } from "../types.js";
 import { ApiFieldMetadata } from "../models/apiResults.js";
-export type FieldValue = string | number | Date | Container;
+import { LayoutBase } from "../layouts/layoutBase.js";
+import { Moment } from "moment";
+export type FieldValue = string | number | Moment | Container;
 export type Container = null;
+export type Parentable = {
+    layout: LayoutBase;
+    type: RecordTypes;
+    endpoint: string;
+};
 export declare class Field<T extends FieldValue> {
-    record: RecordBase<any>;
+    parent: Parentable;
     id: string;
     protected _value: T;
     edited: boolean;
-    constructor(record: any, id: any, contents: any);
-    set(content: string | number | Date | undefined | null): void;
+    constructor(record: Parentable, id: string, contents: T);
+    set(content: T): void;
     get metadata(): ApiFieldMetadata;
     get value(): T;
     set value(value: T);
@@ -20,6 +26,6 @@ export declare class Field<T extends FieldValue> {
     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>;
+    download(mode: DownloadModes.Stream): Promise<http.IncomingMessage>;
+    download(mode: DownloadModes.Buffer): Promise<ContainerBufferResult>;
 }

package/src/records/field.js

@@ -1,22 +1,15 @@
 /*
- * Copyright (c) 2023. See LICENSE file for more information
+ * Copyright (c) 2023-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 { File, FormData } from "node-fetch";
-import { DOWNLOAD_MODES } from "../types.js";
+import { DownloadModes, RecordTypes } from "../types.js";
 import { ApiFieldDisplayTypes, ApiFieldResultTypes, ApiFieldTypes } from "../models/apiResults.js";
 export class Field {
+    parent;
+    id;
+    _value;
+    edited;
     constructor(record, id, contents) {
-        this.record = record;
+        this.parent = record;
         this.id = id;
         this._value = contents;
         this.edited = false;
@@ -24,12 +17,6 @@ export class Field {
     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 = "";
@@ -39,7 +26,7 @@ export class Field {
         this.edited = true;
     }
     get metadata() {
-        if (!this.record.layout.metadata) {
+        if (!this.parent.layout.metadata) {
             // Default to a regular text field
             return {
                 name: this.id.toString(),
@@ -58,9 +45,9 @@ export class Field {
                 valueList: ""
             };
         }
-        if (this.record.type === RecordTypes.PORTAL) {
+        if (this.parent.type === RecordTypes.PORTAL) {
             // @ts-ignore
-            return this.record.layout.metadata.portalMetaData[this.record.portal.name || "portal not attached"].find(i => i.name === this.id) || {
+            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',
@@ -78,7 +65,7 @@ export class Field {
             };
         }
         else {
-            return this.record.layout.metadata.fieldMetaData.find(i => i.name === this.id) || {
+            return this.parent.layout.metadata.fieldMetaData.find(i => i.name === this.id) || {
                 name: this.id.toString(),
                 type: ApiFieldTypes.NORMAL,
                 displayType: ApiFieldDisplayTypes.EDIT_TEXT,
@@ -121,43 +108,40 @@ export class Field {
         }
         throw "Field value is not a number";
     }
-    upload(buffer, filename, mime) {
-        return __awaiter(this, void 0, void 0, function* () {
-            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 }));
-            yield this.record.layout.database.apiRequest(`${this.record.endpoint}/containers/${this.id}/1`, {
-                method: "POST",
-                // @ts-ignore
-                headers: { "content-type": "multipart/form-data" },
-                body: form
-            });
+    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 }));
+        let res = await this.parent.layout.database.apiRequestRaw(`${this.parent.endpoint}/containers/${this.id}/1`, {
+            method: "POST",
+            // @ts-ignore
+            body: form
         });
+        if (!res.ok)
+            throw new Error(`Upload failed with HTTP error: ${res.status} (${res.statusText})`);
     }
-    download(mode = DOWNLOAD_MODES.Stream) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.metadata.result !== ApiFieldResultTypes.CONTAINER)
-                throw new Error("Cannot perform download() on a non-container field");
-            let stream = yield 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
-                    });
+    async download(mode = DownloadModes.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 === DownloadModes.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 → field.ts}

@@ -6,12 +6,13 @@ import * as http from "http";
 import {ContainerBufferResult, DownloadModes, FieldMetaData, RecordTypes} from "../types.js";
 import {ApiFieldDisplayTypes, ApiFieldMetadata, ApiFieldResultTypes, ApiFieldTypes} from "../models/apiResults.js";
 import {LayoutBase} from "../layouts/layoutBase.js";
+import {Moment} from "moment";
 
-export type FieldValue = string | number | Date | Container
+export type FieldValue = string | number | Moment | Container
 export type Container = null
 
 export type Parentable = {layout: LayoutBase, type: RecordTypes, endpoint: string}
-export class FieldBase<T extends FieldValue> {
+export class Field<T extends FieldValue> {
     parent: Parentable;
     id: string;
     protected _value: T;
@@ -24,16 +25,8 @@ export class FieldBase<T extends FieldValue> {
         this.edited = false
     }
 
-    set(content: string | number | Date | undefined | null) {
+    set(content: T) {
         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

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

@@ -4,6 +4,9 @@ import { LayoutBase } from "../../layouts/layoutBase.js";
 import { LayoutRecord } from "../layoutRecord.js";
 import { Query } from "../../utils/query.js";
 export type SortOrder = "ascend" | "descend";
+export type FindRequestRaw = {
+    [key: string]: string;
+};
 export type FindRequest = {
     [key: string]: Query;
 };
@@ -32,7 +35,7 @@ export declare class RecordGetOperation<T extends LayoutInterface, OPTIONS exten
     protected portals: Partial<PortalData<T>>;
     protected offset: number;
     protected queries: {
-        req: FindRequest;
+        req: FindRequestRaw;
         omit: boolean;
     }[];
     constructor(layout: LayoutBase, options: OPTIONS);
@@ -44,6 +47,7 @@ export declare class RecordGetOperation<T extends LayoutInterface, OPTIONS exten
     protected generateParamsURL(offset: number, limit: number): URLSearchParams;
     scripts(scripts: ScriptRequestData): this;
     sort(fieldName: string, sortOrder: SortOrder): this;
+    private parseFindRequest;
     addRequest(query: FindRequest, omit?: boolean): this;
     fetch(): Promise<LayoutRecord<PickPortals<T, keyof OPTIONS["portals"]>>[]>;
     private performFind;

package/src/records/getOperations/recordGetOperation.js

@@ -23,11 +23,11 @@ export class RecordGetOperation {
         return this.queries.length !== 0;
     }
     formatQueries() {
-        return this.queries.map(query => {
+        let test = this.queries.map(query => {
             let out = {};
             for (let key of Object.keys(query.req)) {
-                if (query.req[key][FindRequestSymbol])
-                    out[key] = query.req[key][FindRequestSymbol];
+                if (query.req[key])
+                    out[key] = query.req[key];
                 else {
                     out[key] = query.req[key];
                 }
@@ -36,11 +36,13 @@ export class RecordGetOperation {
                 out.omit = "true";
             return out;
         });
+        return test;
     }
     generateParamsBody(offset, limit) {
         const params = {
             limit: limit.toString(),
             offset: offset.toString(),
+            dateformats: 2 // Ensure dates are received in ISO8601 format
         };
         if (this.sortData.length !== 0)
             params.sort = this.sortData;
@@ -70,6 +72,7 @@ export class RecordGetOperation {
         const params = new URLSearchParams({
             _limit: limit.toString(),
             _offset: offset.toString(),
+            dateformats: "2" // Ensure dates are received in ISO8601 format
         });
         if (this.sortData.length !== 0)
             params.set("_sort", JSON.stringify(this.sortData));
@@ -101,8 +104,23 @@ export class RecordGetOperation {
         this.sortData.push({ fieldName, sortOrder });
         return this;
     }
+    parseFindRequest(query) {
+        let out = {};
+        for (let key of Object.keys(query)) {
+            out[key] = query[key][FindRequestSymbol].map(item => {
+                if (typeof item === "string")
+                    return item;
+                // Re-write date into correct format
+                return item
+                    .clone()
+                    .utcOffset(this.layout.database.host.timezoneOffset)
+                    .format("MM/DD/YYYY HH:mm:ss");
+            }).join("");
+        }
+        return out;
+    }
     addRequest(query, omit = false) {
-        this.queries.push({ req: query, omit });
+        this.queries.push({ req: this.parseFindRequest(query), omit });
         return this;
     }
     fetch() {