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

package/src/connection/database.ts

@@ -2,149 +2,169 @@
  * Copyright (c) 2023-2024. See LICENSE file for more information
  */
 
-import {EventEmitter} from "events";
-import {generateAuthorizationHeaders} from "./generateAuthorizationHeaders.js";
-import {FMError} from "../FMError.js";
-import {LayoutInterface} from "../layouts/layoutInterface.js";
-import {Layout} from "../layouts/layout.js";
-import HTTP_REDIRECT from "follow-redirects"
-import {
-    databaseOptionsBase,
-    databaseOptionsWithExternalSources,
-    loginOptionsFileMaker,
-    loginOptionsToken,
-    Script
-} from "../types.js";
-import {HostBase} from "./HostBase.js"
-import {DatabaseBase} from "./databaseBase.js";
-import {ApiLayout, ApiResults} from "../models/apiResults.js";
-import {DatabaseStructure} from "../databaseStructure.js";
-import {IncomingMessage} from "http";
-
-type GetLayoutReturnType<T extends DatabaseStructure, R extends LayoutInterface | string> = R extends string ? T["layouts"][R] : R
-
+import {EventEmitter} from 'events'
+import {generateAuthorizationHeaders} from './generateAuthorizationHeaders.js'
+import {FMError} from '../FMError.js'
+import {type LayoutInterface} from '../layouts/layoutInterface.js'
+import {Layout} from '../layouts/layout.js'
+import HTTP_REDIRECT from 'follow-redirects'
+import {type databaseOptionsBase, type databaseOptionsWithExternalSources, type Script} from '../types.js'
+import {type HostBase} from './HostBase.js'
+import {type DatabaseBase} from './databaseBase.js'
+import {type ApiLayout, type ApiResults} from '../models/apiResults.js'
+import {type DatabaseStructure} from '../databaseStructure.js'
+import {type IncomingMessage} from 'http'
+
+/**
+ * Represents a database connection.
+ * @template T - The structure of the database.
+ */
 export class Database<T extends DatabaseStructure> extends EventEmitter implements DatabaseBase {
-    private _token: any;
-    readonly host: HostBase;
-    private connection_details: databaseOptionsWithExternalSources
-    private cookies: { [key: string]: string } = {}
-    readonly name: string;
+    private _token: string = ''
+    readonly host: HostBase
+    private readonly connection_details: databaseOptionsWithExternalSources
+    private cookies: Record<string, string> = {}
+    readonly name: string
     readonly debug: boolean
 
-    constructor(host: HostBase, conn: databaseOptionsWithExternalSources) {
+    constructor (host: HostBase, conn: databaseOptionsWithExternalSources) {
         super()
         this.host = host
         this.name = conn.database
         this.connection_details = conn
-        this.debug = !!conn.debug
+        this.debug = conn.debug ?? false
     }
 
-    private generateExternalSourceLogin(data: databaseOptionsBase) {
-        if (data.credentials.method === "filemaker") {
-            let _data = <loginOptionsFileMaker>data.credentials
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    private generateExternalSourceLogin (data: databaseOptionsBase) {
+        if (data.credentials.method === 'filemaker') {
+            const _data = data.credentials
             return {
                 database: data.database,
                 username: _data.username,
                 password: _data.password
             }
-        }
-        else {
-            throw "Not yet supported login method"
+        } else {
+            throw new Error('Not yet supported login method')
         }
     }
 
-    async logout(): Promise<void> {
-        if (!this.token) throw new Error("Not logged in")
-
-        let _fetch = await fetch(`${this.endpoint}/sessions/${this.token}`, {
-            method: "DELETE",
+    /**
+     * Logs out the user by deleting the current session token.
+     * Throws an error if the user is not logged in.
+     *
+     * @returns {Promise<void>} A promise that resolves with no value once the logout is successful.
+     * @throws {Error} Throws an error if the user is not logged in.
+     */
+    async logout (): Promise<void> {
+        if (this.token === '') throw new Error('Not logged in')
+
+        const _fetch = await fetch(`${this.endpoint}/sessions/${this.token}`, {
+            method: 'DELETE',
             headers: {
-                "content-type": "application/json"
+                'content-type': 'application/json'
             }
         })
-        let data = await _fetch.json()
+        await _fetch.json()
         // console.log(data)
-        this._token = null
+        this._token = ''
     }
 
-    async login(forceLogin = false) {
+    /**
+     * Logs in to the database. Not required, as this is often done automatically
+     *
+     * @param {boolean} [forceLogin=false] - Whether to force login even if already logged in.
+     * @throws {Error} - Throws an error if already logged in and forceLogin is false.
+     * @throws {FMError} - Throws an FMError if login fails.
+     * @return {Promise<string>} - Returns a promise that resolves to the access token upon successful login.
+     */
+    async login (forceLogin = false) {
+        // console.trace()
         // Reset cookies
         this.cookies = {}
 
         await this.host.getMetadata()
-        if (this.token && !forceLogin) throw new Error("Already logged in. Run logout() first")
+        if (this.token !== '' && !forceLogin) throw new Error('Already logged in. Run logout() first')
 
-        if (this.connection_details.credentials.method === "token") {
-            this._token = (<loginOptionsToken>this.connection_details.credentials).token
+        if (this.connection_details.credentials.method === 'token') {
+            this._token = (this.connection_details.credentials).token
             return this.token
-        }
-        else {
+        } else {
             console.time()
-            let url = new URL(`${this.endpoint}/sessions`)
+            const url = new URL(`${this.endpoint}/sessions`)
             url.hostname = this.host.hostname
-            let res = await fetch(url, {
-                method: "POST",
+            const res = await fetch(url, {
+                method: 'POST',
                 headers: generateAuthorizationHeaders(this.connection_details.credentials) as unknown as HeadersInit,
                 body: JSON.stringify({
                     fmDataSource: this.connection_details.externalSources.map(i => {
-                        let _i = <databaseOptionsBase>i
+                        const _i = i
                         return this.generateExternalSourceLogin(_i)
                     })
                 })
             })
             console.time()
-            let _res = <any>(await res.json())
+            const _res = (await res.json())
             if (res.status === 200) {
-                this._token = res.headers.get('x-fm-data-access-token')
+                this._token = res.headers.get('x-fm-data-access-token') ?? ''
                 return this._token
-            }
-            else {
-                throw new FMError(_res.messages[0].code, _res.status, res)
+            } else {
+                throw new FMError(
+                    _res.messages[0].code as string | number,
+                    _res.status as number,
+                    res
+                )
             }
         }
     }
 
-    get token() {
+    get token () {
         return this._token
     }
 
-    get endpoint(): string {
+    /**
+     * Returns the endpoint URL for the database connection.
+     *
+     * @returns {string} The endpoint URL.
+     */
+    get endpoint (): string {
         return `${this.host.hostname}/fmi/data/v2/databases/${this.name}`
     }
 
-    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)
+    async _apiRequestRaw (url: string | Request, options: RequestInit & { headers?: Record<string, string> } = {}, autoRelogin = true): Promise<Response> {
+        if (this.debug) console.log(`EASYFM DEBUG: ${JSON.stringify(options)} ${url instanceof Request ? url.url : url}`)
+        if (this.token === '') await this.login(true)
 
         if (!options.headers) options.headers = {}
-        options.headers["authorization"] = "Bearer " + this._token
-        options.rejectUnauthorized = this.host.verify
+        options.headers.authorization = 'Bearer ' + this._token
+        // options.rejectUnauthorized = this.host.verify
 
-        let _fetch = await fetch(url, options)
+        const _fetch = await fetch(url, options)
         if (_fetch.headers.get('set-cookie')) {
-            for (let cookie of _fetch.headers.get('set-cookie') || []) {
-                let cookie_split = cookie.split("=")
-                this.cookies[cookie_split[0]] = cookie_split[1]
+            for (const cookie of _fetch.headers.get('set-cookie') ?? []) {
+                const cookieSplit = cookie.split('=')
+                this.cookies[cookieSplit[0]] = cookieSplit[1]
             }
         }
 
         if (_fetch.status === 401 && autoRelogin) {
             await this.login(true)
-            return await this.apiRequestRaw(url, options, false)
+            return await this._apiRequestRaw(url, options, false)
         }
         return _fetch
     }
-    async apiRequestJSON<T = any>(url: string | Request, options: any = {}): Promise<ApiResults<T>> {
+
+    async _apiRequestJSON<T = any>(url: string | Request, options: RequestInit & { headers?: Record<string, string> } = {}): Promise<ApiResults<T>> {
         if (!options.headers) options.headers = {}
-        options.headers["content-type"] = options.headers["content-type"] ? options.headers["content-type"] : "application/json"
-        let _fetch = await this.apiRequestRaw(url, options)
-        let data = await _fetch.json() as ApiResults<T>
+        options.headers['content-type'] = options.headers['content-type'] ? options.headers['content-type'] : 'application/json'
+        const _fetch = await this._apiRequestRaw(url, options)
+        const data = await _fetch.json() as ApiResults<T>
 
         // Remove response if it is empty. This makes checking for an empty response easier
         if (data.response && Object.keys(data.response).length === 0) delete data.response
 
         // console.log(data.messages[0])
-        if (data.messages[0].code !== "0") {
+        if (data.messages[0].code !== '0') {
             throw new FMError(data.messages[0].code, _fetch.status, data)
         }
 
@@ -152,72 +172,72 @@ export class Database<T extends DatabaseStructure> extends EventEmitter implemen
         return data
     }
 
-    async listLayouts() {
-        let req = await this.apiRequestJSON<{layouts: ApiLayout[]}>(`${this.endpoint}/layouts?page=2`)
+    /**
+     * Retrieves a list of layouts in the current FileMaker database.
+     *
+     * @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`)
         if (!req.response) throw new FMError(req.messages[0].code, req.httpStatus, req.messages[0].message)
 
         const cycleLayoutNames = (layouts: ApiLayout[]) => {
-            let names: string[] =  []
-            for (let layout of layouts) {
+            let names: string[] = []
+            for (const layout of layouts) {
                 if (layout.folderLayoutNames) names = names.concat(cycleLayoutNames(layout.folderLayoutNames))
                 else names.push(layout.name)
             }
             return names
         }
-        let layoutNames
-
         return cycleLayoutNames(req.response.layouts).map(layout => new Layout(this, layout))
     }
 
-    getLayout<R extends keyof T["layouts"]>(name: R): Layout<T["layouts"][R]>
-    getLayout<R extends LayoutInterface>(name: string): Layout<R>
-    getLayout(name: string): Layout<any> {
+    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)
     }
 
-    script(name: string, parameter = ""): Script {
-        return ({name, parameter} as Script)
-    }
-
-    _tokenExpired() {
-        this.emit("token_expired")
+    script (name: string, parameter = ''): Script {
+        return ({ name, parameter } satisfies Script)
     }
 
-    streamURL(url: string): Promise<IncomingMessage> {
-        return new Promise((resolve, reject) => {
-            if (!url || typeof url !== "string") {
-                throw new Error("URL is empty, or has invalid value")
+    async streamURL (url: string): Promise<IncomingMessage> {
+        return await new Promise((resolve, reject) => {
+            if (!url || typeof url !== 'string') {
+                throw new Error('URL is empty, or has invalid value')
             }
 
-            let headers: {[key: string]: string} = {}
+            const headers: Record<string, string> = {}
             if (Object.keys(this.cookies).length !== 0) {
-                headers["Cookie"] = Object.keys(this.cookies)
+                headers.Cookie = Object.keys(this.cookies)
                     .map(key => {
-                        return key + "=" + this.cookies[key]
+                        return key + '=' + this.cookies[key]
                     })
-                    .join("; ")
+                    .join('; ')
             }
 
-            const check_for_cookies = (res: HTTP_REDIRECT.ResponseDetails) => {
+            const checkForCookies = (res: HTTP_REDIRECT.ResponseDetails) => {
                 // Check for the 'set-cookie' header. If it exists, remember it and strip it for better security.
                 if (res.headers['set-cookie']) {
-                    for (let cookie of res.headers['set-cookie']) {
-                        let cookie_split = cookie.split("=")
-                        this.cookies[cookie_split[0]] = cookie_split[1]
+                    for (const cookie of res.headers['set-cookie']) {
+                        const cookieSplit = cookie.split('=')
+                        this.cookies[cookieSplit[0]] = cookieSplit[1]
                     }
                     res.headers['set-cookie'] = undefined
                 }
             }
 
             // Automatically switch between the http and https modules, based on which is needed
-            (url.startsWith("https") ? HTTP_REDIRECT.https : HTTP_REDIRECT.http).get(url, {
+            (url.startsWith('https') ? HTTP_REDIRECT.https : HTTP_REDIRECT.http).get(url, {
                 headers,
-                beforeRedirect: (options: any, res: any) => check_for_cookies(res)
+                beforeRedirect: (options: any, res: HTTP_REDIRECT.ResponseDetails) => { checkForCookies(res) }
             }, (res) => {
-                check_for_cookies(res)
+                checkForCookies(res)
 
                 resolve(res)
             })
         })
     }
-}
+}

package/src/connection/databaseBase.d.ts

@@ -1,12 +1,17 @@
 /// <reference types="node" resolution-mode="require"/>
-import { HostBase } from "./HostBase.js";
-import { ApiResults } from "../models/apiResults.js";
-import { IncomingMessage } from "http";
+import { type HostBase } from './HostBase.js';
+import { type ApiResults } from '../models/apiResults.js';
+import { type IncomingMessage } from 'http';
 export interface DatabaseBase {
     host: HostBase;
     readonly name: string;
     endpoint: string;
-    apiRequestJSON<T = unknown>(url: string | Request, options?: RequestInit | undefined, autoRelogin?: boolean): Promise<ApiResults<T>>;
-    apiRequestRaw(url: string | Request, options?: RequestInit | undefined): Promise<Response>;
-    streamURL(url: string): Promise<IncomingMessage>;
+    token: string;
+    _apiRequestJSON: <T = unknown>(url: string | Request, options?: RequestInit & {
+        headers?: Record<string, string>;
+    } | undefined, autoRelogin?: boolean) => Promise<ApiResults<T>>;
+    _apiRequestRaw: (url: string | Request, options?: RequestInit & {
+        headers?: Record<string, string>;
+    } | undefined) => Promise<Response>;
+    streamURL: (url: string) => Promise<IncomingMessage>;
 }

package/src/connection/databaseBase.ts

@@ -2,18 +2,19 @@
  * Copyright (c) 2023-2024. See LICENSE file for more information
  */
 
-import {HostBase} from "./HostBase.js"
-import {ApiResults} from "../models/apiResults.js";
-import {IncomingMessage} from "http";
+import {type HostBase} from './HostBase.js'
+import {type ApiResults} from '../models/apiResults.js'
+import {type IncomingMessage} from 'http'
 
 export interface DatabaseBase {
-    host: HostBase,
+    host: HostBase
     readonly name: string
     endpoint: string
+    token: string
 
     // layouts: DatabaseStructure["layouts"]
 
-    apiRequestJSON<T = unknown>(url: string | Request, options?: RequestInit | undefined, autoRelogin?: boolean): Promise<ApiResults<T>>
-    apiRequestRaw(url: string | Request, options?: RequestInit | undefined): Promise<Response>
-    streamURL(url: string): Promise<IncomingMessage>
-}
+    _apiRequestJSON: <T = unknown>(url: string | Request, options?: RequestInit & { headers?: Record<string, string> } | undefined, autoRelogin?: boolean) => Promise<ApiResults<T>>
+    _apiRequestRaw: (url: string | Request, options?: RequestInit & { headers?: Record<string, string> } | undefined) => Promise<Response>
+    streamURL: (url: string) => Promise<IncomingMessage>
+}

package/src/connection/generateAuthorizationHeaders.d.ts

@@ -1,2 +1,2 @@
-import { AuthorizationHeaders, AuthorizationHeadersOAuth, loginOptionsClaris, loginOptionsFileMaker, loginOptionsOAuth } from "../types.js";
+import { type AuthorizationHeaders, type AuthorizationHeadersOAuth, type loginOptionsClaris, type loginOptionsFileMaker, type loginOptionsOAuth } from '../types.js';
 export declare function generateAuthorizationHeaders(credentials: loginOptionsOAuth | loginOptionsFileMaker | loginOptionsClaris): AuthorizationHeaders | AuthorizationHeadersOAuth;

package/src/connection/generateAuthorizationHeaders.js

@@ -3,21 +3,21 @@
  */
 export function generateAuthorizationHeaders(credentials) {
     switch (credentials.method) {
-        case "filemaker":
+        case 'filemaker':
             return {
-                "Content-Type": "application/json",
-                "Authorization": "Basic " + Buffer.from(credentials.username + ":" + credentials.password).toString("base64")
+                'Content-Type': 'application/json',
+                Authorization: 'Basic ' + Buffer.from((credentials).username + ':' + (credentials).password).toString('base64')
             };
-        case "claris":
+        case 'claris':
             return {
-                "Content-Type": "application/json",
-                "Authorization": credentials.claris.fmid,
+                'Content-Type': 'application/json',
+                Authorization: (credentials).claris.fmid
             };
-        case "oauth":
+        case 'oauth':
             return {
-                "Content-Type": "application/json",
-                "X-FM-Data-OAuth-RequestId": credentials.oauth.requestId,
-                "X-FM-Data-OAuth-Identifier": credentials.oauth.requestIdentifier
+                'Content-Type': 'application/json',
+                'X-FM-Data-OAuth-RequestId': (credentials).oauth.requestId,
+                'X-FM-Data-OAuth-Identifier': (credentials).oauth.requestIdentifier
             };
     }
 }

package/src/connection/generateAuthorizationHeaders.ts

@@ -3,30 +3,30 @@
  */
 
 import {
-    AuthorizationHeaders,
-    AuthorizationHeadersOAuth,
-    loginOptionsClaris,
-    loginOptionsFileMaker,
-    loginOptionsOAuth
-} from "../types.js";
+    type AuthorizationHeaders,
+    type AuthorizationHeadersOAuth,
+    type loginOptionsClaris,
+    type loginOptionsFileMaker,
+    type loginOptionsOAuth
+} from '../types.js'
 
-export function generateAuthorizationHeaders(credentials: loginOptionsOAuth | loginOptionsFileMaker | loginOptionsClaris): AuthorizationHeaders | AuthorizationHeadersOAuth {
+export function generateAuthorizationHeaders (credentials: loginOptionsOAuth | loginOptionsFileMaker | loginOptionsClaris): AuthorizationHeaders | AuthorizationHeadersOAuth {
     switch (credentials.method) {
-        case "filemaker":
+        case 'filemaker':
             return {
-                "Content-Type": "application/json",
-                "Authorization": "Basic " + Buffer.from((<loginOptionsFileMaker>credentials).username + ":" + (<loginOptionsFileMaker>credentials).password).toString("base64")
-            } as AuthorizationHeaders
-        case "claris":
+                'Content-Type': 'application/json',
+                Authorization: 'Basic ' + Buffer.from((credentials).username + ':' + (credentials).password).toString('base64')
+            } satisfies AuthorizationHeaders
+        case 'claris':
             return {
-                "Content-Type": "application/json",
-                "Authorization": (<loginOptionsClaris>credentials).claris.fmid,
-            } as AuthorizationHeaders
-        case "oauth":
+                'Content-Type': 'application/json',
+                Authorization: (credentials).claris.fmid
+            } satisfies AuthorizationHeaders
+        case 'oauth':
             return {
-                "Content-Type": "application/json",
-                "X-FM-Data-OAuth-RequestId": (<loginOptionsOAuth>credentials).oauth.requestId,
-                "X-FM-Data-OAuth-Identifier": (<loginOptionsOAuth>credentials).oauth.requestIdentifier
-            } as AuthorizationHeadersOAuth
+                'Content-Type': 'application/json',
+                'X-FM-Data-OAuth-RequestId': (credentials).oauth.requestId,
+                'X-FM-Data-OAuth-Identifier': (credentials).oauth.requestIdentifier
+            } satisfies AuthorizationHeadersOAuth
     }
-}
+}

package/src/databaseStructure.d.ts

@@ -1,6 +1,4 @@
-import { LayoutInterface } from "./layouts/layoutInterface.js";
+import { type LayoutInterface } from './layouts/layoutInterface.js';
 export interface DatabaseStructure {
-    layouts: {
-        [key: string]: LayoutInterface;
-    };
+    layouts: Record<string, LayoutInterface>;
 }

package/src/databaseStructure.ts

@@ -3,10 +3,8 @@
  */
 
 // import * as btoa from "btoa";
-import {LayoutInterface} from "./layouts/layoutInterface.js";
+import {type LayoutInterface} from './layouts/layoutInterface.js'
 
 export interface DatabaseStructure {
-    layouts: {
-        [key: string]: LayoutInterface
-    }
-}
+    layouts: Record<string, LayoutInterface>
+}

package/src/index.d.ts

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

package/src/index.js

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