@jd-data-limited/easy-fm 4.1.5 → 4.1.8

package/dist/bin/cli.js

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

package/dist/bin/generateTypes.js

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

package/{src → dist}/connection/FMHost.js

@@ -17,8 +17,9 @@ export default class FMHost {
     constructor(_hostname, timezoneOffset = (moment) => 0 - (new Date()).getTimezoneOffset(), verify = true) {
         if (!(/^https?:\/\//).test(_hostname))
             throw new Error('hostname MUST begin with either http:// or https://');
-        this.protocol = _hostname.startsWith('https:') ? 'https:' : 'http:';
-        this.hostname = _hostname.split('//')[1];
+        const url = new URL(_hostname);
+        this.protocol = url.protocol;
+        this.hostname = url.hostname;
         this.timezoneOffsetFunc = timezoneOffset;
         this.verify = verify;
     }

package/{src → dist}/connection/database.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { EventEmitter } from 'events';
 import { type LayoutInterface } from '../layouts/layoutInterface.js';
 import { Layout } from '../layouts/layout.js';

package/{src → dist}/connection/database.js

@@ -78,27 +78,25 @@ export class Database extends EventEmitter {
             this._token = (this.connection_details.credentials).token;
             return this.token;
         }
-        else {
-            const url = new URL(`${this.endpoint}/sessions`);
-            url.hostname = this.host.hostname;
-            const res = await fetch(url, {
-                method: 'POST',
-                headers: generateAuthorizationHeaders(this.connection_details.credentials),
-                body: JSON.stringify({
-                    fmDataSource: this.connection_details.externalSources.map(i => {
-                        const _i = i;
-                        return this.generateExternalSourceLogin(_i);
-                    })
+        const url = new URL(`${this.endpoint}/sessions`);
+        url.hostname = this.host.hostname;
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: generateAuthorizationHeaders(this.connection_details.credentials),
+            body: JSON.stringify({
+                fmDataSource: this.connection_details.externalSources.map(i => {
+                    const _i = i;
+                    return this.generateExternalSourceLogin(_i);
                 })
-            });
-            const _res = (await res.json());
-            if (res.status === 200) {
-                this._token = res.headers.get('x-fm-data-access-token') ?? '';
-                return this._token;
-            }
-            else {
-                throw new FMError(_res.messages[0].code, _res.status, res);
-            }
+            })
+        });
+        const _res = (await res.json());
+        if (res.status === 200) {
+            this._token = res.headers.get('x-fm-data-access-token') ?? '';
+            return this._token;
+        }
+        else {
+            throw new FMError(_res.messages[0].code, _res.status, res);
         }
     }
     get token() {
@@ -118,35 +116,21 @@ export class Database extends EventEmitter {
                 ? url.toString()
                 : typeof url === 'string' ? url : url.url}`);
         }
-        const reqIsToDBHost = (url instanceof URL
+        const urlParsed = (url instanceof URL
             ? url
             : typeof url === 'string'
                 ? new URL(url)
-                : new URL(url.url)).hostname === this.host.hostname;
+                : new URL(url.url));
+        const reqIsToDBHost = urlParsed.hostname === this.host.hostname && urlParsed.pathname.startsWith("/fmi/data");
         if (reqIsToDBHost && this.token === '')
             await this.login(true);
         if (!options.headers)
             options.headers = {};
         if (reqIsToDBHost)
             options.headers.authorization = 'Bearer ' + this._token;
-        // options.redirect = "manual"
-        // options.headers.cookies = this._generateCookieHeader()
-        // console.log(options.headers.cookies)
-        // options.rejectUnauthorized = this.host.verify
         const _fetch = options.useCookieJar
             ? await fetchWithCookies(this.cookies, url, options)
             : await fetch(url, options);
-        // if (_fetch.headers.get('set-cookie')) {
-        //     console.log(_fetch.headers.get('set-cookie'))
-        //     for (const cookie of (_fetch.headers.get("Set-Cookie") ?? "").split("; ")) {
-        //         const cookieSplit = cookie.split('=')
-        //         console.log("COOKIE SPLIT:", cookieSplit)
-        //         if (cookieSplit[1]) this.cookies[cookieSplit[0]] = cookieSplit[1]
-        //     }
-        // }
-        // console.log(this.cookies, _fetch.status)
-        // // console.log(this, this.cookies, url)
-        // console.trace()
         if (!_fetch.ok && (!options.retries || options.retries > 0)) {
             if (this.debug) {
                 console.log(`EASYFM DEBUG: RE-ATTEMPTING REQUEST (${_fetch.status}) ${url instanceof URL
@@ -186,7 +170,6 @@ export class Database extends EventEmitter {
      */
     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) => {
@@ -213,6 +196,6 @@ export class Database extends EventEmitter {
         this.#layoutCache.clear();
     }
     script(name, parameter = '') {
-        return ({ name, parameter });
+        return { name, parameter };
     }
 }

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+import FMHost from './connection/FMHost.js';
+import type * as TYPES from './types.js';
+export { FMError } from './FMError.js';
+export { type PickPortals } from './types.js';
+export { Database } from './connection/database.js';
+export { Layout } from './layouts/layout.js';
+export { RecordBase } from './records/recordBase.js';
+export { LayoutRecord } from './records/layoutRecord.js';
+export { type LayoutInterface, type PortalInterface } from './layouts/layoutInterface.js';
+export { PortalRecord } from './records/portalRecord.js';
+export { Portal } from './records/portal.js';
+export { type FindRequest, type FindRequestRaw, RecordGetOperation } from './records/getOperations/recordGetOperation.js';
+export { LayoutRecordManager } from './layouts/layoutRecordManager.js';
+export { type RecordFieldsMap } from './layouts/recordFieldsMap.js';
+export { asDate, asTime, asTimestamp, query, queryEscape } from './utils/query.js';
+export { type Container, Field } from './records/field.js';
+export default FMHost;
+export { type TYPES };

package/dist/index.js

@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) 2023-2024. See LICENSE file for more information
+ */
+import FMHost from './connection/FMHost.js';
+export { FMError } from './FMError.js';
+export { Database } from './connection/database.js';
+export { Layout } from './layouts/layout.js';
+export { RecordBase } from './records/recordBase.js';
+export { LayoutRecord } from './records/layoutRecord.js';
+export { PortalRecord } from './records/portalRecord.js';
+export { Portal } from './records/portal.js';
+export { RecordGetOperation } from './records/getOperations/recordGetOperation.js';
+export { LayoutRecordManager } from './layouts/layoutRecordManager.js';
+export { asDate, asTime, asTimestamp, query, queryEscape } from './utils/query.js';
+export { Field } from './records/field.js';
+export default FMHost;

package/{src → dist}/records/field.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { RecordTypes } from '../types.js';
 import { type ApiFieldMetadata } from '../models/apiResults.js';
 import { type LayoutBase } from '../layouts/layoutBase.js';

package/{src → dist}/records/getOperations/recordGetOperation.d.ts

@@ -17,6 +17,10 @@ type PortalData<T extends LayoutInterface> = {
 };
 export interface GetOperationOptions<T extends LayoutInterface> {
     portals: Partial<PortalData<T>>;
+    requests?: Array<{
+        req: FindRequest;
+        omit?: boolean;
+    }>;
     limit?: number;
     offset?: number;
 }
@@ -30,9 +34,9 @@ export declare class RecordGetOperation<T extends LayoutInterface, OPTIONS exten
     }>;
     protected portals: Partial<PortalData<T>>;
     protected offset: number;
-    protected queries: Array<{
+    protected requests: Array<{
         req: FindRequestRaw;
-        omit: boolean;
+        omit?: boolean;
     }>;
     constructor(layout: LayoutBase, options: OPTIONS);
     get isFindRequest(): boolean;

package/{src → dist}/records/getOperations/recordGetOperation.js

@@ -11,19 +11,23 @@ export class RecordGetOperation {
     sortData = [];
     portals;
     offset = 1;
-    queries = [];
+    requests = [];
     constructor(layout, options) {
         this.layout = layout;
         this.sortData = [];
         this.portals = options.portals;
         this.offset = options.offset ?? 1; // Offset refers to the starting record. offset 1 is the same as no offset.
         this.limit = options.limit ?? 100;
+        if (options.requests) {
+            for (const req of options.requests)
+                this.addRequest(req.req, req.omit ?? false);
+        }
     }
     get isFindRequest() {
-        return this.queries.length !== 0;
+        return this.requests.length !== 0;
     }
     formatQueries() {
-        const test = this.queries.map(query => {
+        const test = this.requests.map(query => {
             const out = {};
             for (const key of Object.keys(query.req)) {
                 if (query.req[key])
@@ -58,7 +62,7 @@ export class RecordGetOperation {
             params['script.prerequest'] = this.scriptData.prerequest.name;
         if (this.scriptData.prerequest?.parameter)
             params['script.prerequest.param'] = this.scriptData.prerequest.parameter;
-        if (this.queries.length !== 0)
+        if (this.requests.length !== 0)
             params.query = this.formatQueries();
         const portals = Object.keys(this.portals);
         params.portal = portals;
@@ -146,7 +150,7 @@ export class RecordGetOperation {
      * @return {Object} - The current object instance.
      */
     addRequest(query, omit = false) {
-        this.queries.push({ req: this.parseFindRequest(query), omit });
+        this.requests.push({ req: this.parseFindRequest(query), omit });
         return this;
     }
     /**

package/{src → dist}/records/layoutRecord.d.ts

@@ -32,5 +32,5 @@ export declare class LayoutRecord<LAYOUT extends LayoutInterface> extends Record
     duplicate(): Promise<LayoutRecord<LAYOUT>>;
     delete(): Promise<void>;
     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;
+    toObject(filter?: (a: Field<FieldValue>) => any, portalFilter?: (a: Portal<any>) => any, portalRowFilter?: (a: PortalRecord<any>) => any, portalFieldFilter?: (a: Field<FieldValue>) => any): ApiRowDataDef;
 }

package/{src → dist}/records/layoutRecord.js

@@ -5,7 +5,7 @@ import { RecordBase } from './recordBase.js';
 import { PortalRecord } from './portalRecord.js';
 import { Portal } from './portal.js';
 import { FMError } from '../FMError.js';
-import * as moment from 'moment/moment.js';
+import moment from 'moment';
 export class LayoutRecord extends RecordBase {
     portals = {};
     portalsToInclude;
@@ -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);
             }
@@ -165,12 +168,12 @@ export class LayoutRecord extends RecordBase {
         }
     }
     fieldsToObject(filter = (a) => a.edited) {
-        const fields_processed = {};
+        const fieldsProcessed = {};
         let field;
         for (field of this.fieldsArray.filter(field => filter(field))) {
             let value = field.value;
             if (value instanceof Date) {
-                let _value = moment.default(value);
+                let _value = moment(value);
                 _value = _value
                     .utcOffset(this.layout.database.host.timezoneOffsetFunc(_value));
                 switch (field.metadata.result) {
@@ -184,12 +187,12 @@ export class LayoutRecord extends RecordBase {
                         value = _value.format(this.layout.database.host.timeStampFormat);
                 }
             }
-            fields_processed[field.id] = value;
+            fieldsProcessed[field.id] = value;
         }
         const obj = {
             recordId: this.recordId.toString(),
             modId: this.modId.toString(),
-            fieldData: fields_processed
+            fieldData: fieldsProcessed
         };
         return obj;
     }
@@ -203,7 +206,6 @@ export class LayoutRecord extends RecordBase {
         if (portals) {
             obj.portalData = {};
             for (const portal of portals) {
-                // @ts-expect-error
                 obj.portalData[portal.name] = portal.records.filter(a => portalRowFilter(a)).map(record => {
                     return record.toObject(portalFieldFilter);
                 });

package/{src → dist}/records/recordBase.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { EventEmitter } from 'events';
 import { RecordTypes } from '../types.js';
 import { type RecordFieldsMap } from '../layouts/recordFieldsMap.js';

package/{src → dist}/types.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
 import type * as http from 'http';
 import { type FMError } from './FMError.js';
 import { type LayoutInterface } from './layouts/layoutInterface.js';
@@ -51,6 +49,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/package.json

@@ -1,26 +1,28 @@
 {
   "name": "@jd-data-limited/easy-fm",
-  "version": "4.1.5",
+  "version": "4.1.8",
   "dependencies": {
     "@types/follow-redirects": "^1.14.4",
+    "@types/node": "^22.7.7",
+    "commander": "^14.0.0",
     "follow-redirects": "^1.15.5",
     "moment": "^2.29.4",
     "node-fetch": "^3.3.2",
     "node-fetch-cookies": "^2.1.1"
   },
   "type": "module",
-  "main": "src/index.js",
+  "main": "dist/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).",
   "files": [
-    "./src/**/*"
+    "./dist/**/*"
   ],
   "scripts": {
-    "test": "node --test tests/login.js",
-    "build": "webpack"
+    "build": "tsc",
+    "test": "npm run build && jest"
   },
   "repository": {
     "type": "git",
@@ -28,8 +30,11 @@
   },
   "keywords": [
     "FileMaker",
-    "Data API",
-    "REST"
+    "Data",
+    "API",
+    "REST",
+    "simplicity",
+    "business"
   ],
   "author": "JD-Data Limited",
   "bugs": {
@@ -39,10 +44,16 @@
     "node": ">=20.9.0"
   },
   "devDependencies": {
+    "@babel/cli": "^7.25.7",
+    "@babel/core": "^7.25.8",
+    "@babel/preset-env": "^7.25.8",
+    "@babel/preset-typescript": "^7.25.7",
     "@types/btoa": "^1.2.3",
     "@types/events": "^3.0.0",
     "@types/inquirer": "^9.0.7",
+    "@types/jest": "^29.5.13",
     "@typescript-eslint/eslint-plugin": "^6.21.0",
+    "babel-jest": "^29.7.0",
     "dotenv": "^16.3.1",
     "eslint": "^8.57.0",
     "eslint-config-standard-with-typescript": "^43.0.1",
@@ -50,11 +61,11 @@
     "eslint-plugin-n": "^16.6.2",
     "eslint-plugin-promise": "^6.1.1",
     "inquirer": "^9.2.13",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.5",
     "ts-morph": "^21.0.1",
-    "typedoc": "^0.25.12",
-    "typescript": "^5.4.3",
-    "webpack": "^5.81.0",
-    "webpack-cli": "^5.0.2"
+    "tsx": "^4.19.4",
+    "typescript": "^5.6.3"
   },
   "bin": {
     "easyfm": "src/bin/cli.js"