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

package/package.json

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

package/src/connection/database.d.ts

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

package/src/connection/database.js

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

package/src/connection/database.ts

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

package/src/records/field.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { RecordBase } from "./recordBase.js";
+import * as http from "http";
+import { ContainerBufferResult, DOWNLOAD_MODES } from "../types.js";
+import { ApiFieldMetadata } from "../models/apiResults.js";
+export type FieldValue = string | number | Date | Container;
+export type Container = null;
+export declare class Field<T extends FieldValue> {
+    record: RecordBase<any>;
+    id: string;
+    protected _value: T;
+    edited: boolean;
+    constructor(record: any, id: any, contents: any);
+    set(content: string | number | Date | undefined | null): void;
+    get metadata(): ApiFieldMetadata;
+    get value(): T;
+    set value(value: T);
+    get string(): string;
+    get date(): Date;
+    get number(): number;
+    upload(buffer: Buffer, filename: string, mime: string): Promise<void>;
+    download(mode: DOWNLOAD_MODES.Stream): Promise<http.IncomingMessage>;
+    download(mode: DOWNLOAD_MODES.Buffer): Promise<ContainerBufferResult>;
+}

package/src/records/field.js

@@ -0,0 +1,165 @@
+/*
+ * Copyright (c) 2023. See LICENSE file for more information
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { RecordTypes } from "./recordBase.js";
+import { File, FormData } from "node-fetch";
+import { DOWNLOAD_MODES } from "../types.js";
+import { ApiFieldDisplayTypes, ApiFieldResultTypes, ApiFieldTypes } from "../models/apiResults.js";
+export class Field {
+    constructor(record, id, contents) {
+        this.record = record;
+        this.id = id;
+        this._value = contents;
+        this.edited = false;
+    }
+    set(content) {
+        if (this.metadata.result === "container")
+            throw "Cannot set container value using set(). Use upload() instead.";
+        if ((this.metadata.result === "timeStamp" ||
+            this.metadata.result === "date" ||
+            this.metadata.result === "time")
+            && !(content instanceof Date) && !!content) {
+            throw "Value was not an instance of Date: " + content;
+        }
+        // @ts-ignore
+        if (!content)
+            this._value = "";
+        // @ts-ignore
+        else
+            this._value = content;
+        this.edited = true;
+    }
+    get metadata() {
+        if (!this.record.layout.metadata) {
+            // Default to a regular text field
+            return {
+                name: this.id.toString(),
+                type: ApiFieldTypes.NORMAL,
+                displayType: ApiFieldDisplayTypes.EDIT_TEXT,
+                result: ApiFieldResultTypes.TEXT,
+                global: false,
+                autoEnter: true,
+                fourDigitYear: false,
+                maxRepeat: 1,
+                maxCharacters: 0,
+                notEmpty: false,
+                numeric: false,
+                timeOfDay: false,
+                repetitions: 1,
+                valueList: ""
+            };
+        }
+        if (this.record.type === RecordTypes.PORTAL) {
+            // @ts-ignore
+            return this.record.layout.metadata.portalMetaData[this.record.portal.name || "portal not attached"].find(i => i.name === this.id) || {
+                name: this.id.toString(),
+                type: 'normal',
+                displayType: 'editText',
+                result: 'text',
+                global: false,
+                autoEnter: true,
+                fourDigitYear: false,
+                maxRepeat: 1,
+                maxCharacters: 0,
+                notEmpty: false,
+                numeric: false,
+                timeOfDay: false,
+                repetitionStart: 1,
+                repetitionEnd: 1
+            };
+        }
+        else {
+            return this.record.layout.metadata.fieldMetaData.find(i => i.name === this.id) || {
+                name: this.id.toString(),
+                type: ApiFieldTypes.NORMAL,
+                displayType: ApiFieldDisplayTypes.EDIT_TEXT,
+                result: ApiFieldResultTypes.TEXT,
+                global: false,
+                autoEnter: true,
+                fourDigitYear: false,
+                maxRepeat: 1,
+                maxCharacters: 0,
+                notEmpty: false,
+                numeric: false,
+                timeOfDay: false,
+                repetitions: 1,
+                valueList: ""
+            };
+        }
+    }
+    get value() {
+        // if (this.metadata.result === "container") throw "Use await field.stream() to get the contents of a container field, instead of field.value"
+        return this._value;
+    }
+    set value(value) {
+        this._value = value;
+    }
+    get string() {
+        if (typeof this._value === "string") {
+            return this._value;
+        }
+        throw "Field value is not a string";
+    }
+    get date() {
+        if (this._value instanceof Date) {
+            return this._value;
+        }
+        throw "Field value is not a date";
+    }
+    get number() {
+        if (typeof this._value === "number") {
+            return this._value;
+        }
+        throw "Field value is not a number";
+    }
+    upload(buffer, filename, mime) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let trace = new Error();
+            if (this.metadata.result !== "container")
+                throw "Cannot upload a file to the field; " + this.id + " (not a container field)";
+            let form = new FormData();
+            form.append("upload", new File([buffer], filename, { type: mime }));
+            yield this.record.layout.database.apiRequest(`${this.record.endpoint}/containers/${this.id}/1`, {
+                method: "POST",
+                // @ts-ignore
+                headers: { "content-type": "multipart/form-data" },
+                body: form
+            });
+        });
+    }
+    download(mode = DOWNLOAD_MODES.Stream) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.metadata.result !== ApiFieldResultTypes.CONTAINER)
+                throw new Error("Cannot perform download() on a non-container field");
+            let stream = yield this.record.layout.database.streamURL(this.string);
+            if (mode === DOWNLOAD_MODES.Stream) {
+                return stream;
+            }
+            let body = [];
+            return new Promise((resolve, reject) => {
+                stream.on("data", chunk => {
+                    body.push(chunk);
+                });
+                stream.on("error", (e) => {
+                    reject(e);
+                });
+                stream.on("end", () => {
+                    resolve({
+                        buffer: Buffer.concat(body),
+                        mime: stream.headers["content-type"],
+                        request: stream
+                    });
+                });
+            });
+        });
+    }
+}

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

@@ -0,0 +1,15 @@
+import { RecordGetOperation } from "./recordGetOperation.js";
+import { LayoutRecord } from "../layoutRecord.js";
+import { LayoutInterface } from "../../layouts/layoutInterface";
+import { LayoutBase } from "../../layouts/layoutBase.js";
+export declare class Find<T extends LayoutInterface> extends RecordGetOperation<T> {
+    protected queries: object[];
+    constructor(layout: LayoutBase, start?: number, limit?: number);
+    private toObject;
+    addRequests(...requests: any[]): this;
+    /**
+     * @deprecated in favour of .fetch()
+     */
+    run(): Promise<LayoutRecord<T["fields"], T["portals"]>[]>;
+    fetch(): Promise<LayoutRecord<T["fields"], T["portals"]>[]>;
+}

package/src/records/getOperations/find.js

@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2023. See LICENSE file for more information
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { RecordGetOperation } from "./recordGetOperation.js";
+import { LayoutRecord } from "../layoutRecord.js";
+import { FMError } from "../../FMError.js";
+export class Find extends RecordGetOperation {
+    constructor(layout, start = 0, limit = 100) {
+        super(layout);
+        this.setOffset(start);
+        this.setLimit(limit);
+        this.queries = [];
+    }
+    toObject() {
+        let out = { query: this.queries, sort: undefined };
+        if (this.sort.length !== 0)
+            out.sort = this.sort;
+        for (let item of Object.keys(this.scripts)) {
+            if (this.scripts[item]) {
+                out[item] = this.scripts[item].name;
+                if (this.scripts[item].parameter)
+                    out[item + ".param"] = this.scripts[item].parameter;
+            }
+        }
+        if (this.limit !== 100)
+            out["limit"] = this.limit;
+        if (this.offset !== 0)
+            out["offset"] = this.offset;
+        if (this.limitPortals.length > 0) {
+            out["portal"] = this.limitPortals.map(p => p.portalName);
+            for (let item of this.limitPortals) {
+                out["offset." + item.portalName.replace(/[^0-9A-z]/g, "")] = item.offset;
+                out["limit." + item.portalName.replace(/[^0-9A-z]/g, "")] = item.limit;
+            }
+        }
+        return out;
+    }
+    addRequests(...requests) {
+        for (let item of requests)
+            this.queries.push(item);
+        return this;
+    }
+    /**
+     * @deprecated in favour of .fetch()
+     */
+    run() {
+        return this.fetch();
+    }
+    fetch() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let trace = new Error();
+            yield this.layout.getLayoutMeta();
+            let res = yield this.layout.database.apiRequest(`${this.layout.endpoint}/_find`, {
+                port: 443,
+                method: "POST",
+                body: JSON.stringify(this.toObject())
+            });
+            if (res.messages[0].code === "0") {
+                // console.log("RESOLVING")
+                if (!this.layout.metadata)
+                    yield this.layout.getLayoutMeta();
+                return res.response.data.map(item => {
+                    return new LayoutRecord(this.layout, item.recordId, item.modId, item.fieldData, item.portalData);
+                });
+            }
+            else {
+                throw new FMError(res.messages[0].code, res.httpStatus, res, trace);
+            }
+        });
+    }
+}

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

@@ -0,0 +1,13 @@
+import { LayoutInterface } from "../../layouts/layoutInterface.js";
+import { RecordGetOperation } from "./recordGetOperation.js";
+import { LayoutRecord } from "../layoutRecord.js";
+import { extraBodyOptions } from "../../types.js";
+export declare class RecordGetRange<T extends LayoutInterface> extends RecordGetOperation<T> {
+    constructor(layout: any, start?: number, limit?: number);
+    private generateQueryParams;
+    /**
+     * @deprecated in favour of .fetch()
+     */
+    run(extraBody?: extraBodyOptions): Promise<LayoutRecord<T["fields"], T["portals"]>[]>;
+    fetch(extraBody?: extraBodyOptions): Promise<LayoutRecord<T["fields"], T["portals"]>[]>;
+}

package/src/records/getOperations/recordGetRange.js

@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2023. See LICENSE file for more information
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { RecordGetOperation } from "./recordGetOperation.js";
+import { LayoutRecord } from "../layoutRecord.js";
+import { FMError } from "../../FMError.js";
+export class RecordGetRange extends RecordGetOperation {
+    constructor(layout, start = 0, limit = 100) {
+        super(layout);
+        this.setOffset(start);
+        this.setLimit(limit);
+    }
+    generateQueryParams(extraBody = {}) {
+        let params = [];
+        if (this.limit !== 100)
+            params.push("_limit=" + this.limit);
+        if (this.offset !== 0)
+            params.push("_offset=" + this.offset);
+        if (this.sort.length > 0)
+            params.push("_sort=" + encodeURI(JSON.stringify(this.sort)));
+        if (this.limitPortals.length > 0) {
+            params.push("portal=" + encodeURI(JSON.stringify(this.limitPortals.map(p => p.portalName))));
+            for (let item of this.limitPortals) {
+                if (item.offset !== 0)
+                    params.push("_offset." + item.portalName.replace(/[^0-9A-z]/g, "") + "=" + item.offset);
+                if (item.limit !== 100)
+                    params.push("_limit." + item.portalName.replace(/[^0-9A-z]/g, "") + "=" + item.limit);
+            }
+        }
+        if (extraBody.scripts) {
+            if (extraBody.scripts.prerequest) {
+                params.push("script.prerequest=" + extraBody.scripts.prerequest.name);
+                if (extraBody.scripts.prerequest.parameter)
+                    params.push("script.prerequest.param=" + extraBody.scripts.prerequest.parameter);
+            }
+            if (extraBody.scripts.presort) {
+                params.push("script.presort=" + extraBody.scripts.presort.name);
+                if (extraBody.scripts.presort.parameter)
+                    params.push("script.presort.param=" + extraBody.scripts.presort.parameter);
+            }
+            if (extraBody.scripts.after) {
+                params.push("script=" + extraBody.scripts.after.name);
+                if (extraBody.scripts.after.parameter)
+                    params.push("script.param=" + extraBody.scripts.after.parameter);
+            }
+        }
+        if (params.length === 0)
+            return "";
+        return "?" + params.join("&");
+    }
+    /**
+     * @deprecated in favour of .fetch()
+     */
+    run(extraBody = {}) {
+        return this.fetch(extraBody);
+    }
+    fetch(extraBody = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let trace = new Error();
+            let res = yield this.layout.getLayoutMeta().then(() => {
+                return this.layout.database.apiRequest(`${this.layout.endpoint}/records${this.generateQueryParams(extraBody)}`, {
+                    method: "GET"
+                });
+            });
+            if (res.messages[0].code === "0") {
+                // console.log("RESOLVING")
+                if (!this.layout.metadata)
+                    yield this.layout.getLayoutMeta();
+                let data = res.response.data.map(item => {
+                    return new LayoutRecord(this.layout, item.recordId, item.modId, item.fieldData, item.portalData);
+                });
+                return data;
+            }
+            else {
+                throw new FMError(res.messages[0].code, res.httpStatus, res, trace);
+            }
+        });
+    }
+}

package/src/records/portalRecordBase.d.ts

@@ -0,0 +1,4 @@
+import { RecordBase } from "./recordBase";
+import { RecordFieldsMap } from "../layouts/recordFieldsMap";
+export declare class PortalRecordBase<T extends RecordFieldsMap> extends RecordBase<T> {
+}

package/src/records/portalRecordBase.js

@@ -0,0 +1,6 @@
+/*
+ * Copyright (c) 2023. See LICENSE file for more information
+ */
+import { RecordBase } from "./recordBase";
+export class PortalRecordBase extends RecordBase {
+}

package/src/types.d.ts

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

package/src/types.ts

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

package/src/bin/cli.d.ts

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

package/src/bin/cli.js

@@ -1,19 +0,0 @@
-#!/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();
-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)();
-});
-program.parse(process.argv);

package/src/bin/generateTypes.d.ts

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

package/src/bin/generateTypes.js

@@ -1,250 +0,0 @@
-"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");
-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 apiResults_js_1.ApiFieldResultTypes.TEXT:
-            return "FieldBase<string>";
-        case apiResults_js_1.ApiFieldResultTypes.CONTAINER:
-            return "FieldBase<Container>";
-        case apiResults_js_1.ApiFieldResultTypes.DATE:
-            return "FieldBase<Date>";
-        case apiResults_js_1.ApiFieldResultTypes.NUMBER:
-            return "FieldBase<number>";
-        case apiResults_js_1.ApiFieldResultTypes.TIME:
-            return "FieldBase<Date>";
-        case apiResults_js_1.ApiFieldResultTypes.TIMESTAMP:
-            return "FieldBase<Date>";
-    }
-}
-function processFieldsChunk(fields) {
-    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(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) {
-    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());
-        }
-    }
-    return result;
-}
-function generateTypesCLI() {
-    return __awaiter(this, void 0, void 0, function () {
-        var data, HOST, DATABASE, stream, layouts, layoutInterfaces, _loop_1, _i, layouts_1, layout, layoutInterfaceLinks, _a, layoutInterfaces_1, layout, _b, layoutInterfaces_2, layout;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    process.stdout.write('\x1Bc');
-                    console.log("For this tool to work, you are required to have access to an account on the target database.\n" +
-                        "This account must have the fmrest extended privilege enabled.\n" +
-                        "This tool can only export type interfaces for layouts that the given account has access to.");
-                    console.log("\n");
-                    return [4 /*yield*/, inquirer_1.default.prompt([
-                            {
-                                type: "input",
-                                name: "hostname",
-                                message: "The IP address/domain of your FileMaker server (must start with either http:// or https://)",
-                                validate: function (input) {
-                                    return input.startsWith("http://") || input.startsWith("https://") || "Please enter a valid IP address/domain starting with http:// or https://";
-                                }
-                            },
-                            {
-                                type: "number",
-                                name: "timezoneOffset",
-                                message: "Server timezone offset (minutes)",
-                                default: 0 - (new Date()).getTimezoneOffset()
-                            },
-                            {
-                                type: "confirm",
-                                name: "verify",
-                                default: true,
-                                message: "Verify your server's identity",
-                                when: function (previousAnswers) {
-                                    return previousAnswers.hostname.startsWith("https://");
-                                }
-                            },
-                            {
-                                type: "input",
-                                name: "database",
-                                message: "Database filename"
-                            },
-                            {
-                                type: "input",
-                                name: "username",
-                                message: "Database username"
-                            },
-                            {
-                                type: "password",
-                                name: "password",
-                                message: "Database password",
-                                mask: "*"
-                            }
-                        ])];
-                case 1:
-                    data = _c.sent();
-                    HOST = new FMHost_js_1.default(data.hostname, data.timezoneOffset, data.verify);
-                    DATABASE = HOST.database({
-                        database: data.database,
-                        credentials: {
-                            method: "filemaker",
-                            username: data.username,
-                            password: data.password
-                        },
-                        externalSources: []
-                    });
-                    return [4 /*yield*/, DATABASE.login()
-                        // Create file write stream
-                    ];
-                case 2:
-                    _c.sent();
-                    stream = fs.createWriteStream("./types.ts");
-                    return [4 /*yield*/, DATABASE.listLayouts()];
-                case 3:
-                    layouts = _c.sent();
-                    stream.write("import FMHost, {Container, FieldBase, LayoutInterface, Portal} from \"@jd-data-limited/easy-fm\";\n");
-                    stream.write("// " + layouts.length + " layouts found\n\n");
-                    layoutInterfaces = new Map();
-                    _loop_1 = function (layout) {
-                        var metadata, fields, portals, portalsProcessed, interfaceName;
-                        return __generator(this, function (_d) {
-                            switch (_d.label) {
-                                case 0: return [4 /*yield*/, layout.getLayoutMeta()];
-                                case 1:
-                                    metadata = _d.sent();
-                                    fields = processFieldsChunk(metadata.fieldMetaData);
-                                    portals = metadata.portalMetaData;
-                                    portalsProcessed = Object.keys(portals).map(function (portalName) {
-                                        return "".concat(JSON.stringify(portalName), ": Portal<{").concat(processFieldsChunk(portals[portalName]), "}>");
-                                    });
-                                    interfaceName = sub(layout.name) + "LayoutInterface";
-                                    layoutInterfaces.set(layout.name, {
-                                        interfaceName: interfaceName,
-                                        interface: "export interface ".concat(interfaceName, " extends LayoutInterface {\n            fields: {").concat(fields.join(",\n    "), "},\n            portals: {").concat(portalsProcessed.join(",\n   "), "}\n        }")
-                                    });
-                                    return [2 /*return*/];
-                            }
-                        });
-                    };
-                    _i = 0, layouts_1 = layouts;
-                    _c.label = 4;
-                case 4:
-                    if (!(_i < layouts_1.length)) return [3 /*break*/, 7];
-                    layout = layouts_1[_i];
-                    return [5 /*yield**/, _loop_1(layout)];
-                case 5:
-                    _c.sent();
-                    _c.label = 6;
-                case 6:
-                    _i++;
-                    return [3 /*break*/, 4];
-                case 7:
-                    layoutInterfaceLinks = [];
-                    for (_a = 0, layoutInterfaces_1 = layoutInterfaces; _a < layoutInterfaces_1.length; _a++) {
-                        layout = layoutInterfaces_1[_a];
-                        layoutInterfaceLinks.push([
-                            "".concat(JSON.stringify(layout[0]), ": ").concat(layout[1].interfaceName),
-                            "".concat(sub(camelToSnakeCase(layout[0]).toUpperCase().replace(" ", "_")), ": HOST.getLayout<").concat(layout[1].interfaceName, ">(").concat(JSON.stringify(layout[0]), ")")
-                        ]);
-                    }
-                    stream.write(safeStringInjection(templateObject_1 || (templateObject_1 = __makeTemplateObject(["const HOST = new FMHost(", ", ", ", ", ");"], ["const HOST = new FMHost(", ", ", ", ", ");"])), data.hostname, data.timezoneOffset, data.verify));
-                    stream.write("HOST.database<{layouts:{".concat(layoutInterfaceLinks.map(function (i) { return i[0]; }).join(","), "}}>();"));
-                    stream.write("\n\n");
-                    stream.write("const LAYOUTS = {".concat(layoutInterfaceLinks.map(function (i) { return i[1]; }).join(","), "};"));
-                    for (_b = 0, layoutInterfaces_2 = layoutInterfaces; _b < layoutInterfaces_2.length; _b++) {
-                        layout = layoutInterfaces_2[_b];
-                        stream.write("\n\n");
-                        stream.write(layout[1].interface + ";");
-                    }
-                    // StructureKind
-                    //
-                    // const project = new Project({
-                    //     tsConfigFilePath: "../tsconfig.json"
-                    // })
-                    // project.resolveSourceFileDependencies()
-                    return [4 /*yield*/, DATABASE.logout()];
-                case 8:
-                    // StructureKind
-                    //
-                    // const project = new Project({
-                    //     tsConfigFilePath: "../tsconfig.json"
-                    // })
-                    // project.resolveSourceFileDependencies()
-                    _c.sent();
-                    console.log("DONE! Wrote database types to ./types.ts");
-                    return [2 /*return*/];
-            }
-        });
-    });
-}
-exports.generateTypesCLI = generateTypesCLI;
-var templateObject_1;