@jd-data-limited/easy-fm 4.1.4 → 4.1.6

package/README.md

@@ -15,6 +15,7 @@ FileMaker Data API.
 * [Installation](#installation)
 * [Usage](#usage)
   * [Connecting to a database](#connecting-to-a-database)
+  * [An important note about timezones](#an-important-note-about-timezones)
   * [Getting records](#getting-records)
     * [Fetch a range of records](#fetch-a-range-of-records)
     * [Searching for records](#searching-for-records)
@@ -43,21 +44,11 @@ easy-fm also requires the following to be configured within your FileMaker envir
 
 # Usage
 
-- You need to know what your server's UTC time offset (in minutes) is.
-    - Running `0 - (new Date()).getTimezoneOffset()` in javascript will give you the UTC time offset for your current
-      timezone.
-
 ## Connecting to a database
 
-easy-fm currently does not support connecting to external data sources, or authenticating by any method other than plain
-FileMaker authentication.
-
 ```javascript
-import FMHost, {FMError} from "easy-fm"; // Import the module
-const host = new FMHost(
-    "https://<your-servers-address>",
-    700 // Timezone offset
-)
+import FMHost from "easy-fm"; // Import the module
+const host = new FMHost("https://<your-servers-address>")
 const database = host.database({
     database: "your_database.fmp12",
     credentials: {
@@ -68,17 +59,33 @@ const database = host.database({
     externalSources: []
 })
 
+// OPTIONAL - EasyFM will automatically attempt a login anyway when you perform your first operation
 database.login().then(() => {
-    // Record operations can only be performed after a successful login
+
 })
 ```
 
 > **NOTE:** A connection will only give you access to the layouts in the database you are connected to, and not the
 > layouts
 > in
-> the external sources that you have specified.
+> any external sources that you have specified.
 >
-> If you need to interact with layouts on multiple databases, you need to open one connection per database.
+> If you need to interact with layouts on multiple databases, you need to open a separate connection for each.
+
+## An important note about timezones
+
+Although it is recommended, timestamps in FileMaker databases are not always stored in UTC time. To account for this,
+EasyFM allows you to specify a function/method that determines the server's current timezone.
+EasyFM will use this timezone offset to convert timestamps to and from JavaScript Date objects.
+
+```typescript
+import FMHost from "easy-fm";
+import {type Moment} from 'moment'
+
+const host = new FMHost("https://<your-servers-address>", (moment: Moment) => {
+
+})
+```
 
 ## Getting records
 
@@ -101,6 +108,7 @@ console.log(records)
 ```
 
 ### Searching for records
+
 Searching for records uses the same syntax as above, but with additional steps to add your search parameters.
 
 ```javascript
@@ -218,4 +226,4 @@ const layout = database.getLayout("users") // The UsersLayout interface will be
 const record = await layout.records.create()
 record.fields["first_name"].value = "Joe"
 record.fields["age"].value = 38
-```
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jd-data-limited/easy-fm",
-  "version": "4.1.4",
+  "version": "4.1.6",
   "dependencies": {
     "@types/follow-redirects": "^1.14.4",
     "follow-redirects": "^1.15.5",
@@ -11,7 +11,7 @@
   "type": "module",
   "main": "src/index.js",
   "module": "es2022",
-  "homepage": "https://github.com/JD-Data-Limited/easy-fm",
+  "homepage": "https://jd-data.com/project/easyfm/",
   "url": "https://github.com/JD-Data-Limited/easy-fm",
   "license": "SEE LICENSE IN LICENSE",
   "description": "easy-fm is a Node.js module that allows you to interact with\r a [FileMaker database stored](https://www.claris.com/filemaker/) on\r a [FileMaker server](https://www.claris.com/filemaker/server/). This module interacts with your server using the\r [FileMaker Data API](https://help.claris.com/en/data-api-guide/content/index.html).",
@@ -19,7 +19,7 @@
     "./src/**/*"
   ],
   "scripts": {
-    "test": "node --test tests/login.js",
+    "test": "npx tsc -p . && node --test tests/login.js",
     "build": "webpack"
   },
   "repository": {
@@ -28,8 +28,11 @@
   },
   "keywords": [
     "FileMaker",
-    "Data API",
-    "REST"
+    "Data",
+    "API",
+    "REST",
+    "simplicity",
+    "business"
   ],
   "author": "JD-Data Limited",
   "bugs": {

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/dist/bin/generateTypes.d.ts

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

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:
+        case ApiFieldResultTypes.TEXT:
             return "Field<string>";
-        case apiResults_js_1.ApiFieldResultTypes.CONTAINER:
+        case ApiFieldResultTypes.CONTAINER:
             return "Field<Container>";
-        case apiResults_js_1.ApiFieldResultTypes.DATE:
+        case ApiFieldResultTypes.DATE:
             return "Field<Date>";
-        case apiResults_js_1.ApiFieldResultTypes.NUMBER:
+        case ApiFieldResultTypes.NUMBER:
             return "Field<number>";
-        case apiResults_js_1.ApiFieldResultTypes.TIME:
+        case ApiFieldResultTypes.TIME:
             return "Field<Date>";
-        case apiResults_js_1.ApiFieldResultTypes.TIMESTAMP:
+        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,158 +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 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*/];
+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/connection/database.d.ts

@@ -13,6 +13,7 @@ import { type RequestInfo, type RequestInit, type Response } from 'node-fetch';
  * @template T - The structure of the database.
  */
 export declare class Database<T extends DatabaseStructure> extends EventEmitter implements DatabaseBase {
+    #private;
     private _token;
     readonly host: HostBase;
     private readonly connection_details;
@@ -59,8 +60,9 @@ export declare class Database<T extends DatabaseStructure> extends EventEmitter
      * @returns {Promise<Layout[]>} A promise that resolves to an array of Layout objects.
      * @throws {FMError} If there was an error retrieving the layouts.
      */
-    listLayouts(): Promise<Layout<LayoutInterface>[]>;
+    listLayouts(page?: number): Promise<Layout<LayoutInterface>[]>;
     layout<R extends keyof T['layouts']>(name: R): Layout<T['layouts'][R]>;
     layout<R extends LayoutInterface>(name: string): Layout<R>;
+    clearLayoutCache(): void;
     script(name: string, parameter?: string): Script;
 }

package/src/connection/database.js

@@ -19,6 +19,7 @@ export class Database extends EventEmitter {
     cookies = new CookieJar();
     name;
     debug;
+    #layoutCache = new Map();
     constructor(host, conn) {
         super();
         this.host = host;
@@ -183,8 +184,9 @@ export class Database extends EventEmitter {
      * @returns {Promise<Layout[]>} A promise that resolves to an array of Layout objects.
      * @throws {FMError} If there was an error retrieving the layouts.
      */
-    async listLayouts() {
-        const req = await this._apiRequestJSON(`${this.endpoint}/layouts?page=2`);
+    async listLayouts(page = 0) {
+        const req = await this._apiRequestJSON(`${this.endpoint}/layouts?page=${encodeURIComponent(page)}`);
+        console.log(req);
         if (!req.response)
             throw new FMError(req.messages[0].code, req.httpStatus, req.messages[0].message);
         const cycleLayoutNames = (layouts) => {
@@ -200,7 +202,15 @@ export class Database extends EventEmitter {
         return cycleLayoutNames(req.response.layouts).map(layout => new Layout(this, layout));
     }
     layout(name) {
-        return new Layout(this, name);
+        let layout = this.#layoutCache.get(name);
+        if (layout)
+            return layout;
+        layout = new Layout(this, name);
+        this.#layoutCache.set(name, layout);
+        return layout;
+    }
+    clearLayoutCache() {
+        this.#layoutCache.clear();
     }
     script(name, parameter = '') {
         return ({ name, parameter });

package/src/connection/database.ts

@@ -27,6 +27,7 @@ export class Database<T extends DatabaseStructure> extends EventEmitter implemen
     private cookies = new CookieJar()
     readonly name: string
     readonly debug: boolean
+    readonly #layoutCache = new Map<string, Layout<any>>()
 
     constructor (host: HostBase, conn: databaseOptionsWithExternalSources) {
         super()
@@ -220,8 +221,9 @@ export class Database<T extends DatabaseStructure> extends EventEmitter implemen
      * @returns {Promise<Layout[]>} A promise that resolves to an array of Layout objects.
      * @throws {FMError} If there was an error retrieving the layouts.
      */
-    async listLayouts () {
-        const req = await this._apiRequestJSON<{ layouts: ApiLayout[] }>(`${this.endpoint}/layouts?page=2`)
+    async listLayouts (page: number = 0) {
+        const req = await this._apiRequestJSON<{ layouts: ApiLayout[] }>(`${this.endpoint}/layouts?page=${encodeURIComponent(page)}`)
+        console.log(req)
         if (!req.response) throw new FMError(req.messages[0].code, req.httpStatus, req.messages[0].message)
 
         const cycleLayoutNames = (layouts: ApiLayout[]) => {
@@ -238,7 +240,15 @@ export class Database<T extends DatabaseStructure> extends EventEmitter implemen
     layout<R extends keyof T['layouts']>(name: R): Layout<T['layouts'][R]>
     layout<R extends LayoutInterface>(name: string): Layout<R>
     layout (name: string): Layout<any> {
-        return new Layout<LayoutInterface>(this, name)
+        let layout = this.#layoutCache.get(name)
+        if (layout) return layout
+        layout = new Layout<LayoutInterface>(this, name)
+        this.#layoutCache.set(name, layout)
+        return layout
+    }
+
+    clearLayoutCache () {
+        this.#layoutCache.clear()
     }
 
     script (name: string, parameter = ''): Script {

package/src/records/field.js

@@ -62,7 +62,7 @@ let Field = (() => {
                     if (!req.ok || !req.body) {
                         throw new Error(`HTTP Error: ${req.status} (${req.statusText})`);
                     }
-                    return { data: req.body, mime: req.headers.get("Content-Type") ?? '' };
+                    return { data: req.body, mime: req.headers.get('Content-Type') ?? '' };
                 }, "#streamAsync") }, _private_streamAsync_decorators, { kind: "method", name: "#streamAsync", static: false, private: true, access: { has: obj => #streamAsync in obj, get: obj => obj.#streamAsync }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _arrayBuffer_decorators, { kind: "method", name: "arrayBuffer", static: false, private: false, access: { has: obj => "arrayBuffer" in obj, get: obj => obj.arrayBuffer }, metadata: _metadata }, null, _instanceExtraInitializers);
             if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
@@ -204,7 +204,7 @@ let Field = (() => {
             const req = await this.parent.layout.database._apiRequestRaw(this.string, { useCookieJar: true });
             if (!req.ok)
                 throw new Error(`HTTP Error: ${req.status} (${req.statusText})`);
-            return { data: await req.arrayBuffer(), mime: req.headers.get("Content-Type") ?? '' };
+            return { data: await req.arrayBuffer(), mime: req.headers.get('Content-Type') ?? '' };
         }
     };
 })();

package/src/records/field.ts

@@ -160,12 +160,12 @@ export class Field<T extends FieldValue> {
     }
 
     @containerDownloadFunction
-    async #streamAsync (): Promise<{data: NodeJS.ReadableStream, mime: string}> {
+    async #streamAsync (): Promise<{ data: NodeJS.ReadableStream, mime: string }> {
         const req = await this.parent.layout.database._apiRequestRaw(this.string, {useCookieJar: true})
         if (!req.ok || !req.body) {
             throw new Error(`HTTP Error: ${req.status} (${req.statusText})`)
         }
-        return {data: req.body, mime: req.headers.get("Content-Type") ?? ''}
+        return {data: req.body, mime: req.headers.get('Content-Type') ?? ''}
     }
 
     async stream () {
@@ -173,10 +173,10 @@ export class Field<T extends FieldValue> {
     }
 
     @containerDownloadFunction
-    async arrayBuffer (): Promise<{data: ArrayBuffer, mime: string}> {
+    async arrayBuffer (): Promise<{ data: ArrayBuffer, mime: string }> {
         const req = await this.parent.layout.database._apiRequestRaw(this.string, {useCookieJar: true})
         if (!req.ok) throw new Error(`HTTP Error: ${req.status} (${req.statusText})`)
-        return {data: await req.arrayBuffer(), mime: req.headers.get("Content-Type") ?? ''}
+        return {data: await req.arrayBuffer(), mime: req.headers.get('Content-Type') ?? ''}
     }
 }
 

package/src/records/layoutRecord.js

@@ -44,13 +44,16 @@ export class LayoutRecord extends RecordBase {
             if (extraBody.scripts.presort.parameter)
                 data['script.presort.param'] = extraBody.scripts.presort.parameter;
         }
+        if (extraBody.options)
+            data.options = extraBody.options;
+        if (extraBody.deleteRelatedRecords)
+            data.fieldData.deleteRelated = extraBody.deleteRelatedRecords.map(i => `${i.table}.${i.recordId}`);
         if (this.recordId === -1) {
             // This is a new LayoutRecord
             const res = await this.layout.database._apiRequestJSON(`${this.layout.endpoint}/records`, {
                 method: 'POST',
                 body: JSON.stringify(data)
             });
-            console.log(res);
             if (!res.response) {
                 throw new FMError(res.messages[0].code, res.httpStatus, res);
             }

package/src/records/layoutRecord.ts

@@ -63,6 +63,8 @@ export class LayoutRecord<LAYOUT extends LayoutInterface> extends RecordBase<LAY
             data['script.presort'] = extraBody.scripts.presort.name
             if (extraBody.scripts.presort.parameter) data['script.presort.param'] = extraBody.scripts.presort.parameter
         }
+        if (extraBody.options) data.options = extraBody.options
+        if (extraBody.deleteRelatedRecords) data.fieldData.deleteRelated = extraBody.deleteRelatedRecords.map(i => `${i.table}.${i.recordId}`)
 
         if (this.recordId === -1) {
             // This is a new LayoutRecord
@@ -70,7 +72,6 @@ export class LayoutRecord<LAYOUT extends LayoutInterface> extends RecordBase<LAY
                 method: 'POST',
                 body: JSON.stringify(data)
             })
-            console.log(res)
 
             if (!res.response) {
                 throw new FMError(res.messages[0].code, res.httpStatus, res)

package/src/types.d.ts

@@ -51,6 +51,18 @@ export interface ScriptRequestData {
 }
 export interface extraBodyOptions {
     scripts?: ScriptRequestData;
+    options?: {
+        /**
+         * Defines what entry mode to use (FileMaker Server 2024 and newer)
+         * user (default) - Field validation occurs as per normal. Request is blocked if validation failed.
+         * script - Field validation is overridden/ignored when allowed in the database schema.
+         */
+        entrymode: 'user' | 'script';
+    };
+    deleteRelatedRecords?: Array<{
+        table: string;
+        recordId: number;
+    }>;
 }
 export interface Script {
     name: string;

package/src/types.ts

@@ -63,6 +63,18 @@ export interface ScriptRequestData {
 
 export interface extraBodyOptions {
     scripts?: ScriptRequestData
+    options?: {
+        /**
+         * Defines what entry mode to use (FileMaker Server 2024 and newer)
+         * user (default) - Field validation occurs as per normal. Request is blocked if validation failed.
+         * script - Field validation is overridden/ignored when allowed in the database schema.
+         */
+        entrymode: 'user' | 'script'
+    }
+    deleteRelatedRecords?: Array<{
+        table: string
+        recordId: number
+    }>
 }
 
 export interface Script {