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

package/package.json

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

package/src/bin/cli.js

@@ -1,19 +1,17 @@
 #!/usr/bin/env node
-"use strict";
 /*
  * Copyright (c) 2024. See LICENSE file for more information
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-var commander_1 = require("commander");
-var generateTypes_js_1 = require("./generateTypes.js");
-var program = new commander_1.Command();
+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(function () {
-    (0, generateTypes_js_1.generateTypesCLI)();
+    .action(() => {
+    generateTypesCLI();
 });
 program.parse(process.argv);

package/src/bin/generateTypes.js

@@ -1,53 +1,10 @@
-"use strict";
 /*
  * Copyright (c) 2024. See LICENSE file for more information
  */
-var __makeTemplateObject = (this && this.__makeTemplateObject) || function (cooked, raw) {
-    if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
-    return cooked;
-};
-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());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateTypesCLI = void 0;
-var apiResults_js_1 = require("../models/apiResults.js");
-var inquirer_1 = require("inquirer");
-var FMHost_js_1 = require("../connection/FMHost.js");
-var fs = require("fs");
+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
@@ -55,42 +12,38 @@ function sub(str) {
 }
 function generateFieldType(field) {
     switch (field.result) {
-        case apiResults_js_1.ApiFieldResultTypes.TEXT:
-            return "FieldBase<string>";
-        case apiResults_js_1.ApiFieldResultTypes.CONTAINER:
-            return "FieldBase<Container>";
-        case apiResults_js_1.ApiFieldResultTypes.DATE:
-            return "FieldBase<Date>";
-        case apiResults_js_1.ApiFieldResultTypes.NUMBER:
-            return "FieldBase<number>";
-        case apiResults_js_1.ApiFieldResultTypes.TIME:
-            return "FieldBase<Date>";
-        case apiResults_js_1.ApiFieldResultTypes.TIMESTAMP:
-            return "FieldBase<Date>";
+        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) {
-    var existing_fields = [];
-    fields = fields.filter(function (field) {
+    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(function (field) {
+    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) {
-    var args = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        args[_i - 1] = arguments[_i];
-    }
-    var result = "";
-    for (var i = 0; i < str.length; i++) {
+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());
@@ -98,153 +51,111 @@ function safeStringInjection(str) {
     }
     return result;
 }
-function generateTypesCLI() {
-    return __awaiter(this, void 0, void 0, function () {
-        var data, HOST, DATABASE, stream, layouts, layoutInterfaces, _loop_1, _i, layouts_1, layout, layoutInterfaceLinks, _a, layoutInterfaces_1, layout, _b, layoutInterfaces_2, layout;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    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");
-                    return [4 /*yield*/, inquirer_1.default.prompt([
-                            {
-                                type: "input",
-                                name: "hostname",
-                                message: "The IP address/domain of your FileMaker server (must start with either http:// or https://)",
-                                validate: function (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: function (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: "*"
-                            }
-                        ])];
-                case 1:
-                    data = _c.sent();
-                    HOST = new FMHost_js_1.default(data.hostname, data.timezoneOffset, data.verify);
-                    DATABASE = HOST.database({
-                        database: data.database,
-                        credentials: {
-                            method: "filemaker",
-                            username: data.username,
-                            password: data.password
-                        },
-                        externalSources: []
-                    });
-                    return [4 /*yield*/, DATABASE.login()
-                        // Create file write stream
-                    ];
-                case 2:
-                    _c.sent();
-                    stream = fs.createWriteStream("./types.ts");
-                    return [4 /*yield*/, DATABASE.listLayouts()];
-                case 3:
-                    layouts = _c.sent();
-                    stream.write("import FMHost, {Container, FieldBase, LayoutInterface, Portal} from \"@jd-data-limited/easy-fm\";\n");
-                    stream.write("// " + layouts.length + " layouts found\n\n");
-                    layoutInterfaces = new Map();
-                    _loop_1 = function (layout) {
-                        var metadata, fields, portals, portalsProcessed, interfaceName;
-                        return __generator(this, function (_d) {
-                            switch (_d.label) {
-                                case 0: return [4 /*yield*/, layout.getLayoutMeta()];
-                                case 1:
-                                    metadata = _d.sent();
-                                    fields = processFieldsChunk(metadata.fieldMetaData);
-                                    portals = metadata.portalMetaData;
-                                    portalsProcessed = Object.keys(portals).map(function (portalName) {
-                                        return "".concat(JSON.stringify(portalName), ": Portal<{").concat(processFieldsChunk(portals[portalName]), "}>");
-                                    });
-                                    interfaceName = sub(layout.name) + "LayoutInterface";
-                                    layoutInterfaces.set(layout.name, {
-                                        interfaceName: interfaceName,
-                                        interface: "export interface ".concat(interfaceName, " extends LayoutInterface {\n            fields: {").concat(fields.join(",\n    "), "},\n            portals: {").concat(portalsProcessed.join(",\n   "), "}\n        }")
-                                    });
-                                    return [2 /*return*/];
-                            }
-                        });
-                    };
-                    _i = 0, layouts_1 = layouts;
-                    _c.label = 4;
-                case 4:
-                    if (!(_i < layouts_1.length)) return [3 /*break*/, 7];
-                    layout = layouts_1[_i];
-                    return [5 /*yield**/, _loop_1(layout)];
-                case 5:
-                    _c.sent();
-                    _c.label = 6;
-                case 6:
-                    _i++;
-                    return [3 /*break*/, 4];
-                case 7:
-                    layoutInterfaceLinks = [];
-                    for (_a = 0, layoutInterfaces_1 = layoutInterfaces; _a < layoutInterfaces_1.length; _a++) {
-                        layout = layoutInterfaces_1[_a];
-                        layoutInterfaceLinks.push([
-                            "".concat(JSON.stringify(layout[0]), ": ").concat(layout[1].interfaceName),
-                            "".concat(sub(camelToSnakeCase(layout[0]).toUpperCase().replace(" ", "_")), ": HOST.getLayout<").concat(layout[1].interfaceName, ">(").concat(JSON.stringify(layout[0]), ")")
-                        ]);
-                    }
-                    stream.write(safeStringInjection(templateObject_1 || (templateObject_1 = __makeTemplateObject(["const HOST = new FMHost(", ", ", ", ", ");"], ["const HOST = new FMHost(", ", ", ", ", ");"])), data.hostname, data.timezoneOffset, data.verify));
-                    stream.write("HOST.database<{layouts:{".concat(layoutInterfaceLinks.map(function (i) { return i[0]; }).join(","), "}}>();"));
-                    stream.write("\n\n");
-                    stream.write("const LAYOUTS = {".concat(layoutInterfaceLinks.map(function (i) { return i[1]; }).join(","), "};"));
-                    for (_b = 0, layoutInterfaces_2 = layoutInterfaces; _b < layoutInterfaces_2.length; _b++) {
-                        layout = layoutInterfaces_2[_b];
-                        stream.write("\n\n");
-                        stream.write(layout[1].interface + ";");
-                    }
-                    // StructureKind
-                    //
-                    // const project = new Project({
-                    //     tsConfigFilePath: "../tsconfig.json"
-                    // })
-                    // project.resolveSourceFileDependencies()
-                    return [4 /*yield*/, DATABASE.logout()];
-                case 8:
-                    // StructureKind
-                    //
-                    // const project = new Project({
-                    //     tsConfigFilePath: "../tsconfig.json"
-                    // })
-                    // project.resolveSourceFileDependencies()
-                    _c.sent();
-                    console.log("DONE! Wrote database types to ./types.ts");
-                    return [2 /*return*/];
+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");
 }
-exports.generateTypesCLI = generateTypesCLI;
-var templateObject_1;

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/connection/database.d.ts

@@ -15,6 +15,7 @@ export declare class Database<T extends DatabaseStructure> extends EventEmitter
     private connection_details;
     private cookies;
     readonly name: string;
+    readonly debug: boolean;
     constructor(host: HostBase, conn: databaseOptionsWithExternalSources);
     private generateExternalSourceLogin;
     logout(): Promise<void>;

package/src/connection/database.js

@@ -12,11 +12,13 @@ export class Database extends EventEmitter {
     connection_details;
     cookies = {};
     name;
+    debug;
     constructor(host, conn) {
         super();
         this.host = host;
         this.name = conn.database;
         this.connection_details = conn;
+        this.debug = !!conn.debug;
     }
     generateExternalSourceLogin(data) {
         if (data.credentials.method === "filemaker") {
@@ -86,6 +88,8 @@ export class Database extends EventEmitter {
         return `${this.host.hostname}/fmi/data/v2/databases/${this.name}`;
     }
     async apiRequestRaw(url, options = {}, autoRelogin = true) {
+        if (this.debug)
+            console.log(`EASYFM DEBUG: ${options.method?.toString().toUpperCase() || "GET"} ${url instanceof Request ? url.url : url}`);
         if (!this.token)
             await this.login(true);
         if (!options.headers)

package/src/connection/database.ts

@@ -29,12 +29,14 @@ export class Database<T extends DatabaseStructure> extends EventEmitter implemen
     private connection_details: databaseOptionsWithExternalSources
     private cookies: { [key: string]: string } = {}
     readonly name: string;
+    readonly debug: boolean
 
     constructor(host: HostBase, conn: databaseOptionsWithExternalSources) {
         super()
         this.host = host
         this.name = conn.database
         this.connection_details = conn
+        this.debug = !!conn.debug
     }
 
     private generateExternalSourceLogin(data: databaseOptionsBase) {
@@ -111,6 +113,7 @@ export class Database<T extends DatabaseStructure> extends EventEmitter implemen
     }
 
     async apiRequestRaw(url: string | Request, options: any = {}, autoRelogin = true): Promise<Response> {
+        if (this.debug) console.log(`EASYFM DEBUG: ${options.method?.toString().toUpperCase() || "GET"} ${url instanceof Request ? url.url : url}`)
         if (!this.token) await this.login(true)
 
         if (!options.headers) options.headers = {}

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/{fieldBase.d.ts → field.d.ts}

@@ -4,20 +4,21 @@ import * as http from "http";
 import { ContainerBufferResult, DownloadModes, RecordTypes } from "../types.js";
 import { ApiFieldMetadata } from "../models/apiResults.js";
 import { LayoutBase } from "../layouts/layoutBase.js";
-export type FieldValue = string | number | Date | Container;
+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 FieldBase<T extends FieldValue> {
+export declare class Field<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;
+    set(content: T): void;
     get metadata(): ApiFieldMetadata;
     get value(): T;
     set value(value: T);

package/src/records/{fieldBase.js → field.js}

@@ -3,7 +3,7 @@
  */
 import { DownloadModes, RecordTypes } from "../types.js";
 import { ApiFieldDisplayTypes, ApiFieldResultTypes, ApiFieldTypes } from "../models/apiResults.js";
-export class FieldBase {
+export class Field {
     parent;
     id;
     _value;
@@ -17,12 +17,6 @@ export class FieldBase {
     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 = "";

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() {

package/src/records/getOperations/recordGetOperation.ts

@@ -11,6 +11,9 @@ import {FMError} from "../../FMError.js";
 import {FindRequestSymbol, Query} from "../../utils/query.js";
 
 export type SortOrder = "ascend" | "descend"
+export type FindRequestRaw = {
+    [key: string]: string
+}
 export type FindRequest = {
     [key: string]: Query
 }
@@ -38,7 +41,7 @@ export class RecordGetOperation<T extends LayoutInterface, OPTIONS extends GetOp
     protected sortData: { fieldName: string, sortOrder: SortOrder }[] = []
     protected portals: Partial<PortalData<T>>
     protected offset: number = 1
-    protected queries: {req: FindRequest, omit: boolean}[] = []
+    protected queries: {req: FindRequestRaw, omit: boolean}[] = []
 
     constructor(layout: LayoutBase, options: OPTIONS) {
         this.layout = layout
@@ -53,21 +56,23 @@ export class RecordGetOperation<T extends LayoutInterface, OPTIONS extends GetOp
     }
 
     private formatQueries() {
-        return this.queries.map(query => {
+        let test = this.queries.map(query => {
             let out: any = {}
             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]}
             }
             if (query.omit) out.omit = "true"
             return out
         })
+        return test
     }
 
     protected generateParamsBody(offset: number, limit: number) {
         const params: {[key: string]: any} = {
             limit: limit.toString(),
             offset: offset.toString(),
+            dateformats: 2 // Ensure dates are received in ISO8601 format
         }
         if (this.sortData.length !== 0) params.sort = this.sortData
 
@@ -96,6 +101,7 @@ export class RecordGetOperation<T extends LayoutInterface, OPTIONS extends GetOp
         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))
 
@@ -128,8 +134,24 @@ export class RecordGetOperation<T extends LayoutInterface, OPTIONS extends GetOp
         return this
     }
 
+    private parseFindRequest<I extends FindRequest>(query: I): {[key in keyof I]: string} {
+        let out: any = {}
+        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: FindRequest, omit = false) {
-        this.queries.push({req: query, omit})
+        this.queries.push({req: this.parseFindRequest(query), omit})
         return this
     }
 

package/src/records/layoutRecord.d.ts

@@ -6,7 +6,7 @@ import { LayoutInterface } from "../layouts/layoutInterface.js";
 import { LayoutRecordBase } from "./layoutRecordBase.js";
 import { ApiPortalData, ApiRowDataDef } from "../models/apiResults.js";
 import { LayoutBase } from "../layouts/layoutBase.js";
-import { FieldBase, FieldValue } from "./fieldBase.js";
+import { Field, FieldValue } from "./field.js";
 export declare class LayoutRecord<LAYOUT extends LayoutInterface> extends RecordBase<LAYOUT["fields"]> implements LayoutRecordBase {
     portals: LAYOUT["portals"];
     private readonly portalsToInclude;
@@ -17,6 +17,6 @@ export declare class LayoutRecord<LAYOUT extends LayoutInterface> extends Record
     get(): Promise<this>;
     duplicate(): Promise<LayoutRecord<LAYOUT>>;
     delete(): Promise<void>;
-    fieldsToObject(filter?: (a: FieldBase<FieldValue>) => boolean): Omit<ApiRowDataDef, "portalData">;
-    toObject(filter?: (a: FieldBase<FieldValue>) => any, portalFilter?: (a: Portal<any>) => any, portalRowFilter?: (a: PortalRecord<never>) => any, portalFieldFilter?: (a: FieldBase<FieldValue>) => any): ApiRowDataDef;
+    fieldsToObject(filter?: (a: Field<FieldValue>) => boolean): Omit<ApiRowDataDef, "portalData">;
+    toObject(filter?: (a: Field<FieldValue>) => any, portalFilter?: (a: Portal<any>) => any, portalRowFilter?: (a: PortalRecord<never>) => any, portalFieldFilter?: (a: Field<FieldValue>) => any): ApiRowDataDef;
 }

package/src/records/layoutRecord.js

@@ -186,7 +186,7 @@ export class LayoutRecord extends RecordBase {
     toObject(filter = (a) => a.edited, portalFilter = (a) => a.records.find(record => record.edited), portalRowFilter = (a) => a.edited, portalFieldFilter = (a) => a.edited) {
         let obj = {
             ...this.fieldsToObject(filter),
-            portalData: {}
+            portalData: {},
         };
         // Check if there's been any edited portal information
         let portals = this.portalsArray.filter(a => portalFilter(a));

package/src/records/layoutRecord.ts

@@ -11,8 +11,8 @@ import {FMError} from "../FMError.js";
 import {LayoutRecordBase} from "./layoutRecordBase.js";
 import {ApiFieldData, ApiPortalData, ApiRecordResponseObj, ApiRowDataDef} from "../models/apiResults.js";
 import {LayoutBase} from "../layouts/layoutBase.js"
-import {FieldBase, FieldValue} from "./fieldBase.js";
 import * as moment from "moment/moment.js";
+import {Field, FieldValue} from "./field.js";
 
 export class LayoutRecord<LAYOUT extends LayoutInterface> extends RecordBase<LAYOUT["fields"]> implements LayoutRecordBase {
     // @ts-ignore
@@ -182,9 +182,9 @@ export class LayoutRecord<LAYOUT extends LayoutInterface> extends RecordBase<LAY
         }
     }
 
-    fieldsToObject(filter = (a: FieldBase<FieldValue>) => a.edited): Omit<ApiRowDataDef, "portalData"> {
+    fieldsToObject(filter = (a: Field<FieldValue>) => a.edited): Omit<ApiRowDataDef, "portalData"> {
         let fields_processed: ApiFieldData = {}
-        let field: FieldBase<FieldValue>
+        let field: Field<FieldValue>
         for (field of this.fieldsArray.filter(field => filter(field))) {
             let value = field.value as string | number | Date
             if (value instanceof Date) {
@@ -216,14 +216,14 @@ export class LayoutRecord<LAYOUT extends LayoutInterface> extends RecordBase<LAY
     }
 
     toObject(
-        filter: (a: FieldBase<FieldValue>) => any = (a) => a.edited,
+        filter: (a: Field<FieldValue>) => any = (a) => a.edited,
         portalFilter: (a: Portal<any>) => any = (a) => a.records.find(record => record.edited),
         portalRowFilter: (a: PortalRecord<never>) => any = (a) => a.edited,
-        portalFieldFilter: (a: FieldBase<FieldValue>) => any = (a) => a.edited
+        portalFieldFilter: (a: Field<FieldValue>) => any = (a) => a.edited
     ) {
         let obj: ApiRowDataDef = {
             ...this.fieldsToObject(filter),
-            portalData: {}
+            portalData: {},
         };
 
         // Check if there's been any edited portal information

package/src/records/portalRecord.d.ts

@@ -2,14 +2,14 @@ import { RecordBase } from "./recordBase.js";
 import { extraBodyOptions, RecordTypes } from "../types.js";
 import { RecordFieldsMap } from "../layouts/recordFieldsMap.js";
 import { PortalBase } from "./portalBase.js";
-import { FieldBase, FieldValue } from "./fieldBase.js";
+import { Field, FieldValue } from "./field.js";
 export declare class PortalRecord<T extends RecordFieldsMap> extends RecordBase<T> {
     readonly portal: PortalBase<T>;
     readonly type = RecordTypes.PORTAL;
     constructor(record: RecordBase<any>, portal: PortalBase<any>, recordId: number, modId?: number, fieldData?: {});
     _onSave(): void;
     commit(extraBody?: extraBodyOptions): Promise<import("./layoutRecord.js").LayoutRecord<import("../index.js").LayoutInterface>>;
-    toObject(fieldFilter: (a: FieldBase<FieldValue>) => boolean): {
+    toObject(fieldFilter: (a: Field<FieldValue>) => boolean): {
         modId?: string;
         recordId?: string;
     } & {

package/src/records/portalRecord.ts

@@ -7,7 +7,7 @@ import {extraBodyOptions, RecordTypes} from "../types.js";
 
 import {RecordFieldsMap} from "../layouts/recordFieldsMap.js";
 import {PortalBase} from "./portalBase.js";
-import {FieldBase, FieldValue} from "./fieldBase.js";
+import {Field, FieldValue} from "./field.js";
 
 export class PortalRecord<T extends RecordFieldsMap> extends RecordBase<T> {
     readonly portal: PortalBase<T>;
@@ -27,7 +27,7 @@ export class PortalRecord<T extends RecordFieldsMap> extends RecordBase<T> {
         return this.portal.record.commit(extraBody)
     }
 
-    toObject(fieldFilter: (a: FieldBase<FieldValue>) => boolean): {
+    toObject(fieldFilter: (a: Field<FieldValue>) => boolean): {
         modId?: string,
         recordId?: string,
     } & {[key: string]: string} {

package/src/records/recordBase.d.ts

@@ -1,10 +1,10 @@
 /// <reference types="node" resolution-mode="require"/>
 import { EventEmitter } from "events";
-import { FieldBase, FieldValue } from "./fieldBase.js";
 import { RecordTypes } from "../types.js";
 import { RecordFieldsMap } from "../layouts/recordFieldsMap.js";
 import { LayoutBase } from "../layouts/layoutBase.js";
 import { ApiFieldData } from "../models/apiResults.js";
+import { Field, FieldValue } from "./field.js";
 export declare abstract class RecordBase<T extends RecordFieldsMap> extends EventEmitter {
     readonly layout: LayoutBase;
     readonly type: RecordTypes;
@@ -15,7 +15,7 @@ export declare abstract class RecordBase<T extends RecordFieldsMap> extends Even
     protected constructor(layout: LayoutBase, recordId: number, modId: number | undefined, fieldData: ApiFieldData);
     get endpoint(): string;
     get edited(): boolean;
-    get fieldsArray(): FieldBase<FieldValue>[];
+    get fieldsArray(): Field<FieldValue>[];
     protected processFieldData(fieldData: ApiFieldData): T;
     _onSave(): void;
 }

package/src/records/recordBase.js

@@ -3,8 +3,8 @@
  */
 import { EventEmitter } from "events";
 import * as moment from "moment";
-import { FieldBase } from "./fieldBase.js";
 import { RecordTypes } from "../types.js";
+import { Field } from "./field.js";
 export class RecordBase extends EventEmitter {
     layout;
     type = RecordTypes.UNKNOWN;
@@ -31,14 +31,14 @@ export class RecordBase extends EventEmitter {
     processFieldData(fieldData) {
         let fields = {};
         for (let key of Object.keys(fieldData)) {
-            let _field = new FieldBase(this, key, fieldData[key]);
+            let _field = new Field(this, key, fieldData[key]);
             if (!!fieldData[key]) {
                 if (_field.metadata.result === "timeStamp") {
                     // @ts-ignore
                     let date = moment.default(fieldData[key], this.layout.database.host.metadata.productInfo.timeStampFormat.replace("dd", "DD"))
                         .utcOffset(this.layout.database.host.timezoneOffset, true)
                         .local();
-                    _field.set(date.toDate());
+                    _field.set(date);
                     _field.edited = false;
                 }
                 else if (_field.metadata.result === "time") {
@@ -46,7 +46,7 @@ export class RecordBase extends EventEmitter {
                     let date = moment.default(fieldData[key], this.layout.database.host.metadata.productInfo.timeFormat.replace("dd", "DD"))
                         .utcOffset(this.layout.database.host.timezoneOffset, true)
                         .local();
-                    _field.set(date.toDate());
+                    _field.set(date);
                     _field.edited = false;
                 }
                 else if (_field.metadata.result === "date") {
@@ -54,7 +54,7 @@ export class RecordBase extends EventEmitter {
                     let date = moment.default(fieldData[key], this.layout.database.host.metadata.productInfo.dateFormat.replace("dd", "DD"))
                         .utcOffset(this.layout.database.host.timezoneOffset, true)
                         .local();
-                    _field.set(date.toDate());
+                    _field.set(date);
                     _field.edited = false;
                 }
             }

package/src/records/recordBase.ts

@@ -4,11 +4,12 @@
 
 import {EventEmitter} from "events";
 import * as moment from "moment";
-import {FieldBase, FieldValue} from "./fieldBase.js";
+import {Moment} from "moment";
 import {RecordTypes} from "../types.js";
 import {RecordFieldsMap} from "../layouts/recordFieldsMap.js";
 import {LayoutBase} from "../layouts/layoutBase.js";
 import {ApiFieldData} from "../models/apiResults.js";
+import {Field, FieldValue} from "./field.js";
 
 export abstract class RecordBase<T extends RecordFieldsMap> extends EventEmitter {
     readonly layout: LayoutBase;
@@ -34,7 +35,7 @@ export abstract class RecordBase<T extends RecordFieldsMap> extends EventEmitter
         return !!this.fieldsArray.find(i => i.edited)
     }
 
-    get fieldsArray(): FieldBase<FieldValue>[] {
+    get fieldsArray(): Field<FieldValue>[] {
         return Object.values(this.fields)
     }
 
@@ -42,14 +43,14 @@ export abstract class RecordBase<T extends RecordFieldsMap> extends EventEmitter
         let fields: RecordFieldsMap = {}
 
         for (let key of Object.keys(fieldData)) {
-            let _field = new FieldBase(this, key, fieldData[key])
+            let _field = new Field<number | string | Moment>(this, key, fieldData[key])
             if (!!fieldData[key]) {
                 if (_field.metadata.result === "timeStamp") {
                     // @ts-ignore
                     let date = moment.default(fieldData[key], this.layout.database.host.metadata.productInfo.timeStampFormat.replace("dd", "DD"))
                         .utcOffset(this.layout.database.host.timezoneOffset, true)
                         .local()
-                    _field.set(date.toDate())
+                    _field.set(date)
                     _field.edited = false
 
                 }
@@ -58,7 +59,7 @@ export abstract class RecordBase<T extends RecordFieldsMap> extends EventEmitter
                     let date = moment.default(fieldData[key], this.layout.database.host.metadata.productInfo.timeFormat.replace("dd", "DD"))
                         .utcOffset(this.layout.database.host.timezoneOffset, true)
                         .local()
-                    _field.set(date.toDate())
+                    _field.set(date)
                     _field.edited = false
                 }
                 else if (_field.metadata.result === "date") {
@@ -66,7 +67,7 @@ export abstract class RecordBase<T extends RecordFieldsMap> extends EventEmitter
                     let date = moment.default(fieldData[key], this.layout.database.host.metadata.productInfo.dateFormat.replace("dd", "DD"))
                         .utcOffset(this.layout.database.host.timezoneOffset, true)
                         .local()
-                    _field.set(date.toDate())
+                    _field.set(date)
                     _field.edited = false
                 }
             }

package/src/types.d.ts

@@ -8,6 +8,7 @@ export type PickPortals<LAYOUT extends LayoutInterface, PORTALS extends string |
 };
 export interface databaseOptionsBase {
     database: string;
+    debug?: boolean;
     credentials: loginOptionsOAuth | loginOptionsFileMaker | loginOptionsClaris | loginOptionsToken;
 }
 export interface databaseOptionsWithExternalSources extends databaseOptionsBase {

package/src/types.ts

@@ -12,7 +12,8 @@ export type PickPortals<LAYOUT extends LayoutInterface, PORTALS extends string |
     Omit<LAYOUT, "portals"> & { portals: Pick<LAYOUT["portals"], PORTALS> }
 
 export interface databaseOptionsBase {
-    database: string
+    database: string,
+    debug?: boolean,
     credentials: loginOptionsOAuth | loginOptionsFileMaker | loginOptionsClaris | loginOptionsToken,
 }
 

package/src/utils/query.d.ts

@@ -1,10 +1,9 @@
+import { Moment } from "moment";
 export declare const FindRequestSymbol: unique symbol;
-type QueryParameter = string | number | Date;
+type QueryParameter = string | number | Moment;
 export type Query = {
-    [FindRequestSymbol]: string;
+    [FindRequestSymbol]: (string | Moment)[];
 };
 export declare function queryEscape(str: string): string;
-export declare function query(strings: TemplateStringsArray, ...args: QueryParameter[]): {
-    [FindRequestSymbol]: string;
-};
+export declare function query(strings: TemplateStringsArray, ...args: QueryParameter[]): Query;
 export {};

package/src/utils/query.js

@@ -1,6 +1,7 @@
 /*
  * Copyright (c) 2024. See LICENSE file for more information
  */
+import moment from "moment/moment.js";
 export const FindRequestSymbol = Symbol("easyfm-findrequest");
 const SPECIAL_CHARACTERS = ["\\", "=", "<", "≤", "≥", ">", "…", "...", "//", "@", "#", "*", "\"", "~"];
 export function queryEscape(str) {
@@ -11,11 +12,17 @@ export function queryEscape(str) {
 }
 export function query(strings, ...args) {
     let argStrings = args.map(item => {
-        return queryEscape(item.toString());
+        if (moment.isMoment(item))
+            return item;
+        else if (typeof item === "number") {
+            return queryEscape(item.toString());
+        }
+        else
+            return queryEscape(item);
     });
     // Zip the parameters together
     const query = strings.map((str, index) => {
-        return str + (argStrings[index] || '');
-    });
-    return { [FindRequestSymbol]: query.join("") };
+        return [str, (argStrings[index] || '')];
+    }).flat(1);
+    return { [FindRequestSymbol]: query };
 }

package/src/utils/query.ts

@@ -2,10 +2,13 @@
  * Copyright (c) 2024. See LICENSE file for more information
  */
 
+import {Moment} from "moment";
+import moment from "moment/moment.js";
+
 export const FindRequestSymbol = Symbol("easyfm-findrequest");
 const SPECIAL_CHARACTERS = ["\\", "=", "<", "≤", "≥", ">", "…", "...", "//", "@", "#", "*", "\"", "~"]
-type QueryParameter = string | number | Date
-export type Query = {[FindRequestSymbol]: string}
+type QueryParameter = string | number | Moment
+export type Query = {[FindRequestSymbol]: (string | Moment)[]}
 
 export function queryEscape(str: string) {
     for (let char of SPECIAL_CHARACTERS) {
@@ -14,14 +17,18 @@ export function queryEscape(str: string) {
     return str
 }
 
-export function query(strings: TemplateStringsArray, ...args: QueryParameter[]) {
+export function query(strings: TemplateStringsArray, ...args: QueryParameter[]): Query {
     let argStrings = args.map(item => {
-        return queryEscape(item.toString())
+        if (moment.isMoment(item)) return item
+        else if (typeof item === "number") {
+            return queryEscape(item.toString())
+        }
+        else return queryEscape(item)
     })
 
     // Zip the parameters together
     const query = strings.map((str, index) => {
-        return str + (argStrings[index] || '')
-    })
-    return {[FindRequestSymbol]: query.join("")}
+        return [str, (argStrings[index] || '')]
+    }).flat(1)
+    return {[FindRequestSymbol]: query}
 }