@jd-data-limited/easy-fm 4.0.14 → 4.0.16

package/package.json

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

package/src/bin/cli.js

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

package/src/bin/generateTypes.js

@@ -1,10 +1,53 @@
+"use strict";
 /*
  * 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";
+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");
 function sub(str) {
     return str
         .replace(/[^a-zA-Z0-9_]/g, "") // Remove non-alphanumeric characters
@@ -12,38 +55,42 @@ function sub(str) {
 }
 function generateFieldType(field) {
     switch (field.result) {
-        case ApiFieldResultTypes.TEXT:
+        case apiResults_js_1.ApiFieldResultTypes.TEXT:
             return "Field<string>";
-        case ApiFieldResultTypes.CONTAINER:
+        case apiResults_js_1.ApiFieldResultTypes.CONTAINER:
             return "Field<Container>";
-        case ApiFieldResultTypes.DATE:
+        case apiResults_js_1.ApiFieldResultTypes.DATE:
             return "Field<Date>";
-        case ApiFieldResultTypes.NUMBER:
+        case apiResults_js_1.ApiFieldResultTypes.NUMBER:
             return "Field<number>";
-        case ApiFieldResultTypes.TIME:
+        case apiResults_js_1.ApiFieldResultTypes.TIME:
             return "Field<Date>";
-        case ApiFieldResultTypes.TIMESTAMP:
+        case apiResults_js_1.ApiFieldResultTypes.TIMESTAMP:
             return "Field<Date>";
     }
 }
 function processFieldsChunk(fields) {
-    let existing_fields = [];
-    fields = fields.filter(field => {
+    var existing_fields = [];
+    fields = fields.filter(function (field) {
         if (existing_fields.includes(field.name))
             return false;
         existing_fields.push(field.name);
         return true;
     });
-    return fields.map(field => {
+    return fields.map(function (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++) {
+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++) {
         result += str[i];
         if (i < args.length) {
             result += JSON.stringify(args[i].toString());
@@ -51,111 +98,158 @@ function safeStringInjection(str, ...args) {
     }
     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://");
+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 substituteName, metadata, fields, portals, portalsProcessed, interfaceName;
+                        return __generator(this, function (_d) {
+                            switch (_d.label) {
+                                case 0:
+                                    substituteName = sub(layout.name);
+                                    if (!substituteName)
+                                        return [2 /*return*/, "continue"];
+                                    console.log(substituteName);
+                                    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 = substituteName + "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*/];
             }
-        },
-        {
-            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/connection/FMHost.d.ts

@@ -2,13 +2,17 @@ import { Database } from "./database.js";
 import { HostBase } from "./HostBase.js";
 import { databaseOptionsWithExternalSources, FMHostMetadata, loginOptionsClaris, loginOptionsFileMaker, loginOptionsOAuth } from "../types.js";
 import { DatabaseStructure } from "../databaseStructure.js";
+import { Moment } from "moment";
 export default class FMHost implements HostBase {
     readonly hostname: string;
-    readonly timezoneOffset: number;
+    readonly timezoneOffsetFunc: (moment: Moment) => number;
     readonly verify: boolean;
     _metadata: FMHostMetadata | null;
-    constructor(_hostname: string, timezoneOffset?: number, verify?: boolean);
+    constructor(_hostname: string, timezoneOffset?: (moment: Moment) => number, verify?: boolean);
     get metadata(): FMHostMetadata;
+    get dateFormat(): string;
+    get timeFormat(): string;
+    get timeStampFormat(): string;
     listDatabases(credentials?: loginOptionsOAuth | loginOptionsFileMaker | loginOptionsClaris): Promise<any>;
     database<T extends DatabaseStructure>(data: databaseOptionsWithExternalSources): Database<T>;
     getMetadata(): Promise<FMHostMetadata>;

package/src/connection/FMHost.js

@@ -6,14 +6,14 @@ import { FMError } from "../FMError.js";
 import { Database } from "./database.js";
 export default class FMHost {
     hostname;
-    timezoneOffset;
+    timezoneOffsetFunc;
     verify;
     _metadata = null;
-    constructor(_hostname, timezoneOffset = 0 - (new Date()).getTimezoneOffset(), verify = true) {
+    constructor(_hostname, timezoneOffset = (moment) => 0 - (new Date()).getTimezoneOffset(), verify = true) {
         if (!(/^https?:\/\//).test(_hostname))
             throw "hostname MUST begin with either http:// or https://";
         this.hostname = _hostname;
-        this.timezoneOffset = timezoneOffset;
+        this.timezoneOffsetFunc = timezoneOffset;
         this.verify = verify;
     }
     get metadata() {
@@ -22,12 +22,23 @@ export default class FMHost {
                 buildDate: new Date(),
                 name: "",
                 version: "",
-                dateFormat: "",
-                timeFormat: "",
-                timeStampFormat: ""
+                dateFormat: "MM/dd/yyyy",
+                timeFormat: "HH:mm:ss",
+                timeStampFormat: "MM/dd/yyyy HH:mm:ss"
             }
         };
     }
+    get dateFormat() {
+        return this.metadata.productInfo.dateFormat
+            .replace("dd", "DD")
+            .replace("yyyy", "YYYY");
+    }
+    get timeFormat() { return this.metadata.productInfo.timeFormat; }
+    get timeStampFormat() {
+        return this.metadata.productInfo.timeStampFormat
+            .replace("dd", "DD")
+            .replace("yyyy", "YYYY");
+    }
     async listDatabases(credentials) {
         let headers = {};
         if (credentials) {

package/src/connection/FMHost.ts

@@ -15,17 +15,22 @@ import {
 } from "../types.js";
 import {ApiResults} from "../models/apiResults.js";
 import {DatabaseStructure} from "../databaseStructure.js";
+import {Moment} from "moment";
 
 export default class FMHost implements HostBase {
     readonly hostname: string
-    readonly timezoneOffset: number
+    readonly timezoneOffsetFunc: (moment: Moment) => number
     readonly verify: boolean
     _metadata: FMHostMetadata | null = null
 
-    constructor(_hostname: string, timezoneOffset = 0 - (new Date()).getTimezoneOffset(), verify = true) {
+    constructor(
+        _hostname: string,
+        timezoneOffset = (moment: Moment) => 0 - (new Date()).getTimezoneOffset(),
+        verify = true
+    ) {
         if (!(/^https?:\/\//).test(_hostname)) throw "hostname MUST begin with either http:// or https://"
         this.hostname = _hostname
-        this.timezoneOffset = timezoneOffset
+        this.timezoneOffsetFunc = timezoneOffset
         this.verify = verify
     }
 
@@ -35,13 +40,26 @@ export default class FMHost implements HostBase {
                 buildDate: new Date(),
                 name: "",
                 version: "",
-                dateFormat: "",
-                timeFormat: "",
-                timeStampFormat: ""
+                dateFormat: "MM/dd/yyyy",
+                timeFormat: "HH:mm:ss",
+                timeStampFormat: "MM/dd/yyyy HH:mm:ss"
             }
         };
     }
 
+    get dateFormat() {
+        return this.metadata.productInfo.dateFormat
+            .replace("dd", "DD")
+            .replace("yyyy", "YYYY")
+    }
+
+    get timeFormat() {return this.metadata.productInfo.timeFormat}
+    get timeStampFormat() {
+        return this.metadata.productInfo.timeStampFormat
+            .replace("dd", "DD")
+            .replace("yyyy", "YYYY")
+    }
+
     async listDatabases(credentials?: loginOptionsOAuth | loginOptionsFileMaker | loginOptionsClaris) {
         let headers = {}
         if (credentials) {

package/src/connection/HostBase.d.ts

@@ -1,8 +1,12 @@
 import { FMHostMetadata } from "../types.js";
+import { Moment } from "moment";
 export interface HostBase {
     readonly hostname: string;
-    readonly timezoneOffset: number;
+    readonly timezoneOffsetFunc: (moment: Moment) => number;
     readonly verify: boolean;
     metadata: FMHostMetadata;
     getMetadata(): PromiseLike<any>;
+    timeFormat: string;
+    dateFormat: string;
+    timeStampFormat: string;
 }

package/src/connection/HostBase.ts

@@ -3,11 +3,15 @@
  */
 
 import {FMHostMetadata} from "../types.js";
+import {Moment} from "moment";
 
 export interface HostBase {
     readonly hostname: string
-    readonly timezoneOffset: number
+    readonly timezoneOffsetFunc: (moment: Moment) => number,
     readonly verify: boolean
     metadata: FMHostMetadata
     getMetadata(): PromiseLike<any>
+    timeFormat: string
+    dateFormat: string
+    timeStampFormat: string
 }

package/src/index.d.ts

@@ -12,7 +12,7 @@ import { Portal } from "./records/portal.js";
 import { FindRequest, 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 { asDate, asTime, asTimestamp, 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, Field, RecordGetOperation, LayoutRecordManager, Container, PickPortals, FindRequestRaw, FindRequest, query, queryEscape };
+export { FMError, TYPES, Database, Layout, RecordBase, LayoutRecord, LayoutInterface, RecordFieldsMap, PortalInterface, PortalRecord, Portal, Field, RecordGetOperation, LayoutRecordManager, Container, PickPortals, FindRequestRaw, FindRequest, query, queryEscape, asDate, asTime, asTimestamp };

package/src/index.js

@@ -12,7 +12,7 @@ import { PortalRecord } from "./records/portalRecord.js";
 import { Portal } from "./records/portal.js";
 import { RecordGetOperation } from "./records/getOperations/recordGetOperation.js";
 import { LayoutRecordManager } from "./layouts/layoutRecordManager.js";
-import { query, queryEscape } from "./utils/query.js";
+import { asDate, asTime, asTimestamp, query, queryEscape } from "./utils/query.js";
 import { Field } from "./records/field.js";
 export default FMHost;
-export { FMError, TYPES, Database, Layout, RecordBase, LayoutRecord, PortalRecord, Portal, Field, RecordGetOperation, LayoutRecordManager, query, queryEscape };
+export { FMError, TYPES, Database, Layout, RecordBase, LayoutRecord, PortalRecord, Portal, Field, RecordGetOperation, LayoutRecordManager, query, queryEscape, asDate, asTime, asTimestamp };

package/src/index.ts

@@ -16,7 +16,7 @@ import {Portal} from "./records/portal.js";
 import {FindRequest, 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 {asDate, asTime, asTimestamp, query, queryEscape} from "./utils/query.js";
 import {Container, Field} from "./records/field.js";
 
 export default FMHost
@@ -40,5 +40,8 @@ export {
     FindRequestRaw,
     FindRequest,
     query,
-    queryEscape
+    queryEscape,
+    asDate,
+    asTime,
+    asTimestamp
 }

package/src/records/getOperations/recordGetOperation.js

@@ -112,9 +112,14 @@ export class RecordGetOperation {
                     return item;
                 // Re-write date into correct format
                 return item
+                    .moment
                     .clone()
-                    .utcOffset(this.layout.database.host.timezoneOffset)
-                    .format("MM/DD/YYYY HH:mm:ss");
+                    .utcOffset(this.layout.database.host.timezoneOffsetFunc(item.moment))
+                    .format(item.type === "date" ?
+                    this.layout.database.host.dateFormat :
+                    item.type == "time" ?
+                        this.layout.database.host.timeFormat :
+                        this.layout.database.host.timeStampFormat);
             }).join("");
         }
         return out;

package/src/records/getOperations/recordGetOperation.ts

@@ -41,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: FindRequestRaw, omit: boolean}[] = []
+    protected queries: { req: FindRequestRaw, omit: boolean }[] = []
 
     constructor(layout: LayoutBase, options: OPTIONS) {
         this.layout = layout
@@ -60,7 +60,9 @@ export class RecordGetOperation<T extends LayoutInterface, OPTIONS extends GetOp
             let out: any = {}
             for (let key of Object.keys(query.req)) {
                 if (query.req[key]) out[key] = query.req[key]
-                else {out[key] = query.req[key]}
+                else {
+                    out[key] = query.req[key]
+                }
             }
             if (query.omit) out.omit = "true"
             return out
@@ -69,7 +71,7 @@ export class RecordGetOperation<T extends LayoutInterface, OPTIONS extends GetOp
     }
 
     protected generateParamsBody(offset: number, limit: number) {
-        const params: {[key: string]: any} = {
+        const params: { [key: string]: any } = {
             limit: limit.toString(),
             offset: offset.toString(),
             dateformats: 2 // Ensure dates are received in ISO8601 format
@@ -97,6 +99,7 @@ export class RecordGetOperation<T extends LayoutInterface, OPTIONS extends GetOp
 
         return params
     }
+
     protected generateParamsURL(offset: number, limit: number) {
         const params = new URLSearchParams({
             _limit: limit.toString(),
@@ -134,7 +137,7 @@ export class RecordGetOperation<T extends LayoutInterface, OPTIONS extends GetOp
         return this
     }
 
-    private parseFindRequest<I extends FindRequest>(query: I): {[key in keyof I]: string} {
+    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 => {
@@ -142,9 +145,16 @@ export class RecordGetOperation<T extends LayoutInterface, OPTIONS extends GetOp
 
                 // Re-write date into correct format
                 return item
+                    .moment
                     .clone()
-                    .utcOffset(this.layout.database.host.timezoneOffset)
-                    .format("MM/DD/YYYY HH:mm:ss")
+                    .utcOffset(this.layout.database.host.timezoneOffsetFunc(item.moment))
+                    .format(
+                        item.type === "date" ?
+                            this.layout.database.host.dateFormat :
+                            item.type == "time" ?
+                                this.layout.database.host.timeFormat :
+                                this.layout.database.host.timeStampFormat
+                    )
             }).join("")
         }
         return out
@@ -189,7 +199,7 @@ export class RecordGetOperation<T extends LayoutInterface, OPTIONS extends GetOp
             else {
                 throw new FMError(res.messages[0].code, res.httpStatus, res, trace)
             }
-        } catch(e) {
+        } catch (e) {
             if (e instanceof FMError) {
                 if (e.code === 401) {
                     // No records found, so return empty set

package/src/records/layoutRecord.js

@@ -160,18 +160,19 @@ export class LayoutRecord extends RecordBase {
             let value = field.value;
             if (value instanceof Date) {
                 // @ts-ignore
-                let _value = moment.default(value)
-                    .utcOffset(this.layout.database.host.timezoneOffset);
+                let _value = moment.default(value);
+                _value = _value
+                    .utcOffset(this.layout.database.host.timezoneOffsetFunc(_value));
                 // @ts-ignore
                 switch (field.metadata.result) {
                     case "time":
-                        value = _value.format(this.layout.database.host.metadata.productInfo.timeFormat.replace("dd", "DD"));
+                        value = _value.format(this.layout.database.host.timeFormat);
                         break;
                     case "date":
-                        value = _value.format(this.layout.database.host.metadata.productInfo.dateFormat.replace("dd", "DD"));
+                        value = _value.format(this.layout.database.host.dateFormat);
                         break;
                     default:
-                        value = _value.format(this.layout.database.host.metadata.productInfo.timeStampFormat.replace("dd", "DD"));
+                        value = _value.format(this.layout.database.host.timeStampFormat);
                 }
             }
             fields_processed[field.id] = value;

package/src/records/layoutRecord.ts

@@ -190,19 +190,20 @@ export class LayoutRecord<LAYOUT extends LayoutInterface> extends RecordBase<LAY
             if (value instanceof Date) {
                 // @ts-ignore
                 let _value = moment.default(value)
-                    .utcOffset(this.layout.database.host.timezoneOffset)
+                _value = _value
+                    .utcOffset(this.layout.database.host.timezoneOffsetFunc(_value))
 
                 // @ts-ignore
 
                 switch (field.metadata.result) {
                     case "time":
-                        value = _value.format(this.layout.database.host.metadata.productInfo.timeFormat.replace("dd", "DD"))
+                        value = _value.format(this.layout.database.host.timeFormat)
                         break
                     case "date":
-                        value = _value.format(this.layout.database.host.metadata.productInfo.dateFormat.replace("dd", "DD"))
+                        value = _value.format(this.layout.database.host.dateFormat)
                         break
                     default:
-                        value = _value.format(this.layout.database.host.metadata.productInfo.timeStampFormat.replace("dd", "DD"))
+                        value = _value.format(this.layout.database.host.timeStampFormat)
                 }
             }
             fields_processed[field.id] = value

package/src/records/recordBase.js

@@ -35,24 +35,27 @@ export class RecordBase extends EventEmitter {
             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)
+                    let date = moment.default(fieldData[key]);
+                    date = date
+                        .utcOffset(this.layout.database.host.timezoneOffsetFunc(date), true)
                         .local();
                     _field.set(date);
                     _field.edited = false;
                 }
                 else if (_field.metadata.result === "time") {
                     // @ts-ignore
-                    let date = moment.default(fieldData[key], this.layout.database.host.metadata.productInfo.timeFormat.replace("dd", "DD"))
-                        .utcOffset(this.layout.database.host.timezoneOffset, true)
+                    let date = moment.default(fieldData[key]);
+                    date = date
+                        .utcOffset(this.layout.database.host.timezoneOffsetFunc(date), true)
                         .local();
                     _field.set(date);
                     _field.edited = false;
                 }
                 else if (_field.metadata.result === "date") {
                     // @ts-ignore
-                    let date = moment.default(fieldData[key], this.layout.database.host.metadata.productInfo.dateFormat.replace("dd", "DD"))
-                        .utcOffset(this.layout.database.host.timezoneOffset, true)
+                    let date = moment.default(fieldData[key]);
+                    date = date
+                        .utcOffset(this.layout.database.host.timezoneOffsetFunc(date), true)
                         .local();
                     _field.set(date);
                     _field.edited = false;

package/src/records/recordBase.ts

@@ -47,8 +47,9 @@ export abstract class RecordBase<T extends RecordFieldsMap> extends EventEmitter
             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)
+                    let date = moment.default(fieldData[key])
+                    date = date
+                        .utcOffset(this.layout.database.host.timezoneOffsetFunc(date), true)
                         .local()
                     _field.set(date)
                     _field.edited = false
@@ -56,16 +57,18 @@ export abstract class RecordBase<T extends RecordFieldsMap> extends EventEmitter
                 }
                 else if (_field.metadata.result === "time") {
                     // @ts-ignore
-                    let date = moment.default(fieldData[key], this.layout.database.host.metadata.productInfo.timeFormat.replace("dd", "DD"))
-                        .utcOffset(this.layout.database.host.timezoneOffset, true)
+                    let date = moment.default(fieldData[key])
+                    date = date
+                        .utcOffset(this.layout.database.host.timezoneOffsetFunc(date), true)
                         .local()
                     _field.set(date)
                     _field.edited = false
                 }
                 else if (_field.metadata.result === "date") {
                     // @ts-ignore
-                    let date = moment.default(fieldData[key], this.layout.database.host.metadata.productInfo.dateFormat.replace("dd", "DD"))
-                        .utcOffset(this.layout.database.host.timezoneOffset, true)
+                    let date = moment.default(fieldData[key])
+                    date = date
+                        .utcOffset(this.layout.database.host.timezoneOffsetFunc(date), true)
                         .local()
                     _field.set(date)
                     _field.edited = false

package/src/utils/query.d.ts

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

package/src/utils/query.js

@@ -1,7 +1,7 @@
 /*
  * Copyright (c) 2024. See LICENSE file for more information
  */
-import moment from "moment/moment.js";
+import moment from "moment";
 export const FindRequestSymbol = Symbol("easyfm-findrequest");
 const SPECIAL_CHARACTERS = ["\\", "=", "<", "≤", "≥", ">", "…", "...", "//", "@", "#", "*", "\"", "~"];
 export function queryEscape(str) {
@@ -12,13 +12,13 @@ export function queryEscape(str) {
 }
 export function query(strings, ...args) {
     let argStrings = args.map(item => {
-        if (moment.isMoment(item))
-            return item;
-        else if (typeof item === "number") {
+        if (typeof item === "number") {
             return queryEscape(item.toString());
         }
-        else
+        else if (typeof item === "string")
             return queryEscape(item);
+        else
+            return item;
     });
     // Zip the parameters together
     const query = strings.map((str, index) => {
@@ -26,3 +26,22 @@ export function query(strings, ...args) {
     }).flat(1);
     return { [FindRequestSymbol]: query };
 }
+export function asDate(date) {
+    return {
+        type: "date",
+        moment: moment(date)
+    };
+}
+export function asTime(date) {
+    return {
+        type: "time",
+        moment: moment(date)
+    };
+}
+export function asTimestamp(date) {
+    return {
+        type: "timestamp",
+        moment: moment(date)
+    };
+}
+query;

package/src/utils/query.ts

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