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

package/src/records/layoutRecord.ts

@@ -1,247 +0,0 @@
-/*
- * Copyright (c) 2023-2024. See LICENSE file for more information
- */
-
-import {type extraBodyOptions} from '../types.js'
-import {RecordBase} from './recordBase.js'
-import {PortalRecord} from './portalRecord.js'
-import {Portal} from './portal.js'
-import {type LayoutInterface} from '../layouts/layoutInterface.js'
-import {FMError} from '../FMError.js'
-import {type LayoutRecordBase} from './layoutRecordBase.js'
-import {
-    type ApiFieldData,
-    type ApiPortalData,
-    type ApiRecordResponseObj,
-    type ApiRowDataDef
-} from '../models/apiResults.js'
-import {type LayoutBase} from '../layouts/layoutBase.js'
-import * as moment from 'moment/moment.js'
-import {type Field, type FieldValue} from './field.js'
-
-export class LayoutRecord<LAYOUT extends LayoutInterface> extends RecordBase<LAYOUT['fields']> implements LayoutRecordBase {
-    portals: LAYOUT['portals'] = {}
-    private readonly portalsToInclude: Array<string | number | symbol>
-
-    constructor (
-        layout: LayoutBase,
-        recordId: number | string,
-        modId = recordId,
-        fieldData: Record<string, string | number> = {},
-        portalData: ApiPortalData | null = null, portalsToInclude: Array<keyof LAYOUT['portals']> = []) {
-        super(layout, parseInt(recordId as string), parseInt(modId as string), fieldData)
-        this.portalsToInclude = portalsToInclude
-        if (portalData) {
-            this.processPortalData(portalData)
-        }
-    }
-
-    get portalsArray (): Array<Portal<any>> {
-        return Object.values(this.portals)
-    }
-
-    /**
-     * Asynchronously commits the changes made to the current record.
-     * @param {extraBodyOptions} extraBody - The options for the extra body elements.
-     * @returns {Promise<this>} - A promise that resolves with the modified object.
-     * @throws {FMError} - If an error occurs during the commit process.
-     */
-    async commit (extraBody: extraBodyOptions = {}): Promise<this> {
-        const data: any = this.toObject()
-        delete data.recordId
-        delete data.modId
-
-        if (extraBody.scripts?.after) {
-            data.script = extraBody.scripts.after.name
-            if (extraBody.scripts.after.parameter) data['script.param'] = extraBody.scripts.after.parameter
-        }
-        if (extraBody.scripts?.prerequest) {
-            data['script.prerequest'] = extraBody.scripts.prerequest.name
-            if (extraBody.scripts.prerequest.parameter) data['script.prerequest.param'] = extraBody.scripts.prerequest.parameter
-        }
-        if (extraBody.scripts?.presort) {
-            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
-            const res = await this.layout.database._apiRequestJSON<{ recordId: string, modId: string }>(`${this.layout.endpoint}/records`, {
-                method: 'POST',
-                body: JSON.stringify(data)
-            })
-
-            if (!res.response) {
-                throw new FMError(res.messages[0].code, res.httpStatus, res)
-            } else if (typeof res.response.scriptError !== 'undefined' && res.response.scriptError !== '0') {
-                throw new FMError(res.response.scriptError, res.httpStatus, res)
-            } else if (res.messages[0].code === '0') {
-                this.recordId = parseInt(res.response.recordId)
-                this.modId = parseInt(res.response.modId)
-                return this
-            } else {
-                throw new FMError(res.messages[0].code, res.httpStatus, res)
-            }
-        }
-
-        // for (let item of Object.keys(data)) extraBody[item] = data[item]
-        const res = await this.layout.database._apiRequestJSON<{
-            modId: string,
-            newPortalRecordInfo: Array<{
-                tableName: string
-                recordId: string
-                modId: string
-            }>
-        }>(this.endpoint, {
-            method: 'PATCH',
-            body: JSON.stringify(data)
-        })
-        if (!res.response) {
-            throw new FMError(res.messages[0].code, res.httpStatus, res)
-        } else if (typeof res.response.scriptError !== 'undefined' && res.response.scriptError !== '0') {
-            throw new FMError(res.response.scriptError, res.httpStatus, res)
-        } else if (res.messages[0].code === '0') {
-            this.modId = +res.response.modId
-            this._onSave()
-            return this
-        } else {
-            throw new FMError(res.messages[0].code, res.httpStatus, res)
-        }
-    }
-
-    protected processPortalData (portalData: ApiPortalData): void {
-        for (const portalName of Object.keys(portalData)) {
-            const _portal = new Portal(this, portalName)
-            _portal.records = portalData[portalName].map(item => {
-                const fieldData = item
-                delete fieldData.recordId
-                delete fieldData.modId
-                return new PortalRecord(this, _portal, parseInt(item.recordId as string), parseInt(item.modId as string), fieldData)
-            })
-
-            // @ts-expect-error - This code is actually correct, but throws a typescript error
-            this.portals[portalName] = _portal
-        }
-    }
-
-    /**
-     * Re-fetches the current record from the database server.
-     * Throws an error if commit() has not been called.
-     *
-     * @return {Promise<this>} A Promise that resolves to this RecordBase instance if the record is successfully retrieved.
-     * @throws {Error} If commit() has not been called.
-     * @throws {FMError} If the retrieval fails.
-     */
-    async get (): Promise<this> {
-        if (this.recordId === -1) {
-            throw new Error('Cannot get this RecordBase until a commit() is done.')
-        }
-        if (!this.layout.metadata) await this.layout.getLayoutMeta()
-        const res = await this.layout.database._apiRequestJSON<ApiRecordResponseObj>(this.endpoint, {
-            method: 'GET'
-        })
-
-        if (res.response && res.messages[0].code === '0') {
-            // console.log(res, res.response.data)
-            this.modId = +res.response.data[0].modId
-            this.processFieldData(res.response.data[0].fieldData)
-            this.portalData = []
-            if (res.response.data[0].portalData) this.processPortalData(res.response.data[0].portalData)
-            return this
-        } else {
-            throw new FMError(res.messages[0].code, res.httpStatus, res)
-        }
-    }
-
-    async duplicate (): Promise<LayoutRecord<LAYOUT>> {
-        const trace = new Error()
-        const res = await this.layout.database._apiRequestJSON<{ recordId: string, modId: string }>(this.endpoint, {
-            method: 'POST'
-        })
-        if (!res.response) {
-            throw new FMError(res.messages[0].code, res.httpStatus, res, trace)
-        } else if (typeof res.response.scriptError !== 'undefined' && res.response.scriptError !== '0') {
-            throw new FMError(res.response.scriptError, res.httpStatus, res, trace)
-        } else if (res.messages[0].code === '0') {
-            const data = this.toObject((a) => true, (a) => true, (a) => false, (a) => false)
-            const _res = new LayoutRecord<LAYOUT>(this.layout, res.response.recordId, res.response.modId, data.fieldData, data.portalData)
-
-            this.emit('duplicated')
-            return _res
-        } else {
-            throw new FMError(res.messages[0].code, res.httpStatus, res, trace)
-        }
-    }
-
-    async delete (): Promise<void> {
-        const res = await this.layout.database._apiRequestJSON(this.endpoint, {
-            method: 'DELETE'
-        })
-        if (typeof res.response?.scriptError !== 'undefined' && res.response?.scriptError !== '0') {
-            throw new FMError(res.response.scriptError, res.httpStatus, res)
-        } else if (res.messages[0].code === '0') {
-            this.emit('deleted')
-        } else {
-            throw new FMError(res.messages[0].code, res.httpStatus, res)
-        }
-    }
-
-    fieldsToObject (filter = (a: Field<FieldValue>) => a.edited): Omit<ApiRowDataDef, 'portalData'> {
-        const fields_processed: ApiFieldData = {}
-        let field: Field<FieldValue>
-        for (field of this.fieldsArray.filter(field => filter(field))) {
-            let value = field.value as string | number | Date
-            if (value instanceof Date) {
-                let _value = moment.default(value)
-                _value = _value
-                    .utcOffset(this.layout.database.host.timezoneOffsetFunc(_value))
-
-                switch (field.metadata.result) {
-                    case 'time':
-                        value = _value.format(this.layout.database.host.timeFormat)
-                        break
-                    case 'date':
-                        value = _value.format(this.layout.database.host.dateFormat)
-                        break
-                    default:
-                        value = _value.format(this.layout.database.host.timeStampFormat)
-                }
-            }
-            fields_processed[field.id] = value
-        }
-        const obj = {
-            recordId: this.recordId.toString(),
-            modId: this.modId.toString(),
-            fieldData: fields_processed
-        }
-        return obj
-    }
-
-    toObject (
-        filter: (a: Field<FieldValue>) => any = (a) => a.edited,
-        portalFilter: (a: Portal<any>) => any = (a) => a.records.find(record => record.edited),
-        portalRowFilter: (a: PortalRecord<never>) => any = (a) => a.edited,
-        portalFieldFilter: (a: Field<FieldValue>) => any = (a) => a.edited
-    ) {
-        const obj: ApiRowDataDef = {
-            ...this.fieldsToObject(filter),
-            portalData: {}
-        }
-
-        // Check if there's been any edited portal information
-        const portals = this.portalsArray.filter(a => portalFilter(a))
-        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)
-                })
-            }
-        }
-
-        return obj
-    }
-}

package/src/records/layoutRecordBase.ts

@@ -1,10 +0,0 @@
-/*
- * Copyright (c) 2023. See LICENSE file for more information
- */
-
-import {type LayoutBase} from '../layouts/layoutBase.js'
-
-export interface LayoutRecordBase {
-    layout: LayoutBase
-    commit: (extraBody: object) => Promise<this>
-}

package/src/records/portal.ts

@@ -1,43 +0,0 @@
-/*
- * Copyright (c) 2023-2024. See LICENSE file for more information
- */
-
-import {PortalRecord} from './portalRecord.js'
-import {type RecordFieldsMap} from '../layouts/recordFieldsMap.js'
-import {type PortalBase} from './portalBase.js'
-import {type LayoutRecord} from './layoutRecord.js'
-
-/**
- * Represents a portal.
- *
- * @template T - The type of RecordFieldsMap.
- * @class
- * @implements {PortalBase<T>}
- */
-export class Portal<T extends RecordFieldsMap> implements PortalBase<T> {
-    readonly record: LayoutRecord<any>
-    readonly name: string
-    public records: Array<PortalRecord<T>> = []
-
-    constructor (record: LayoutRecord<any>, name: string) {
-        this.record = record
-        this.name = name
-    }
-
-    /**
-     * Add a new record to the portal
-     * @function create
-     * @async
-     * @summary Creates a new record.
-     * @returns {Promise<PortalRecord<T>>} A Promise that resolves to the newly created record.
-     */
-    async create () {
-        const fields: Record<string, string> = {}
-        for (const _field of (await this.record.layout.getLayoutMeta()).portalMetaData[this.name]) {
-            fields[_field.name] = ''
-        }
-        const record = new PortalRecord<T>(this.record, this, -1, -1, fields)
-        this.records.push(record)
-        return record
-    }
-}

package/src/records/portalBase.ts

@@ -1,14 +0,0 @@
-/*
- * Copyright (c) 2023-2024. See LICENSE file for more information
- */
-
-import {type RecordFieldsMap} from '../layouts/recordFieldsMap.js'
-import {type RecordBase} from './recordBase.js'
-import {type LayoutRecord} from './layoutRecord.js'
-import {type LayoutInterface} from '../layouts/layoutInterface.js'
-
-export interface PortalBase<T extends RecordFieldsMap> {
-    readonly record: LayoutRecord<LayoutInterface>
-    readonly name: string
-    records: Array<RecordBase<T>>
-}

package/src/records/portalRecord.ts

@@ -1,52 +0,0 @@
-/*
- * Copyright (c) 2023-2024. See LICENSE file for more information
- */
-
-import {RecordBase} from './recordBase.js'
-import {type extraBodyOptions, RecordTypes} from '../types.js'
-
-import {type RecordFieldsMap} from '../layouts/recordFieldsMap.js'
-import {type PortalBase} from './portalBase.js'
-import {type Field, type FieldValue} from './field.js'
-
-/**
- * Represents a PortalRecord, which is a record in a portal within a parent record.
- * @template T - The type of the record's field map.
- */
-export class PortalRecord<T extends RecordFieldsMap> extends RecordBase<T> {
-    readonly portal: PortalBase<T>
-    readonly type = RecordTypes.PORTAL
-
-    constructor (record: RecordBase<any>, portal: PortalBase<any>, recordId: number, modId = recordId, fieldData = {}) {
-        super(record.layout, recordId, modId, fieldData)
-        this.portal = portal
-    }
-
-    _onSave () {
-        super._onSave()
-        this.portal.record._onSave()
-    }
-
-    /**
-     * Commits the parent record, and in turn this one.
-     *
-     * @param {extraBodyOptions} [extraBody={}] - The optional extra body options.
-     * @returns {Promise} - A promise that resolves when the record is committed.
-     */
-    async commit (extraBody: extraBodyOptions = {}) {
-        return await this.portal.record.commit(extraBody)
-    }
-
-    toObject (fieldFilter: (a: Field<FieldValue>) => boolean): {
-        modId?: string
-        recordId?: string
-    } & Record<string, string> {
-        const res: any = {
-            recordId: this.recordId === -1 ? undefined : this.recordId.toString(),
-            modId: this.modId === -1 ? undefined : this.modId.toString()
-        }
-        for (const field of this.fieldsArray.filter(a => fieldFilter(a))) res[field.id] = field.value?.toString()
-        // console.log(res)
-        return res
-    }
-}

package/src/records/recordBase.ts

@@ -1,91 +0,0 @@
-/*
- * Copyright (c) 2023-2024. See LICENSE file for more information
- */
-
-import {EventEmitter} from 'events'
-import * as moment from 'moment'
-import {type Moment} from 'moment'
-import {RecordTypes} from '../types.js'
-import {type RecordFieldsMap} from '../layouts/recordFieldsMap.js'
-import {type LayoutBase} from '../layouts/layoutBase.js'
-import {type ApiFieldData} from '../models/apiResults.js'
-import {Field, type FieldValue} from './field.js'
-
-export abstract class RecordBase<T extends RecordFieldsMap> extends EventEmitter {
-    readonly layout: LayoutBase
-    readonly type: RecordTypes = RecordTypes.UNKNOWN
-    public recordId: number
-    modId: number
-    /**
-     * An object containing each field in this record.
-     *
-     * @template T - The type of the field.
-     */
-    fields: T
-    protected portalData: any[] = []
-
-    protected constructor (layout: LayoutBase, recordId: number, modId = recordId, fieldData: ApiFieldData) {
-        super()
-        this.layout = layout
-        this.recordId = recordId
-        this.modId = modId
-        this.fields = this.processFieldData(fieldData)
-    }
-
-    get endpoint (): string {
-        return `${this.layout.endpoint}/records/${this.recordId}`
-    }
-
-    /**
-     * A boolean indicating whether this record has been modified and should be committed
-     *
-     * @returns {boolean} A boolean value indicating whether any of the fields have been edited.
-     */
-    get edited (): boolean {
-        return !!this.fieldsArray.find(i => i.edited)
-    }
-
-    get fieldsArray (): Array<Field<FieldValue>> {
-        return Object.values(this.fields)
-    }
-
-    protected processFieldData (fieldData: ApiFieldData) {
-        const fields: RecordFieldsMap = {}
-
-        for (const key of Object.keys(fieldData)) {
-            const _field = new Field<number | string | Moment>(this, key, fieldData[key])
-            if (fieldData[key]) {
-                if (_field.metadata.result === 'timeStamp') {
-                    let date = moment.default(fieldData[key])
-                    date = date
-                        .utcOffset(this.layout.database.host.timezoneOffsetFunc(date), true)
-                        .local()
-                    _field.set(date)
-                    _field.edited = false
-                } else if (_field.metadata.result === 'time') {
-                    let date = moment.default(fieldData[key])
-                    date = date
-                        .utcOffset(this.layout.database.host.timezoneOffsetFunc(date), true)
-                        .local()
-                    _field.set(date)
-                    _field.edited = false
-                } else if (_field.metadata.result === 'date') {
-                    let date = moment.default(fieldData[key])
-                    date = date
-                        .utcOffset(this.layout.database.host.timezoneOffsetFunc(date), true)
-                        .local()
-                    _field.set(date)
-                    _field.edited = false
-                }
-            }
-            fields[key] = _field
-        }
-        this.fields = fields as T
-        return fields as T
-    }
-
-    _onSave () {
-        this.emit('saved')
-        for (const field of this.fieldsArray) field.edited = false
-    }
-}

package/src/types.ts

@@ -1,162 +0,0 @@
-/*
- * Copyright (c) 2022-2024. See LICENSE file for more information
- */
-
-// const fetch = (...args) => import('node-fetch').then(({default: fetch}) => fetch(...args));
-import type * as http from 'http'
-import {type FMError} from './FMError.js'
-import {type LayoutInterface} from './layouts/layoutInterface.js'
-
-export type PickPortals<LAYOUT extends LayoutInterface, PORTALS extends string | number | symbol = ''> =
-    Omit<LAYOUT, 'portals'> & { portals: Pick<LAYOUT['portals'], PORTALS> }
-
-export interface databaseOptionsBase {
-    database: string
-    debug?: boolean
-    credentials: loginOptionsOAuth | loginOptionsFileMaker | loginOptionsClaris | loginOptionsToken
-}
-
-export interface databaseOptionsWithExternalSources extends databaseOptionsBase {
-    database: string
-    debug?: boolean
-    credentials: loginOptionsOAuth | loginOptionsFileMaker | loginOptionsClaris | loginOptionsToken
-    externalSources: databaseOptionsBase[]
-}
-
-export interface loginOptionsToken {
-    method: 'token'
-    token: string
-}
-
-export interface loginOptionsOAuth {
-    method: 'oauth'
-    oauth: {
-        requestId: string
-        requestIdentifier: string
-    }
-}
-
-export interface loginOptionsFileMaker {
-    method: 'filemaker'
-    username: string
-    password: string
-}
-
-export interface loginOptionsClaris {
-    method: 'claris'
-    claris: {
-        fmid: string
-    }
-}
-
-export interface portalFetchData<T = string> {
-    portalName: T
-    offset: number
-    limit: number
-}
-
-export interface ScriptRequestData {
-    prerequest?: Script
-    presort?: Script
-    after?: Script
-}
-
-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
-    parameter: string
-}
-
-export interface recordObject {
-    recordId: number
-    modId: number
-    fieldData: any
-    portalData?: portalDataObject
-}
-
-export type portalDataObject = Record<string, recordObject>
-
-export interface FieldMetaData {
-    name: string
-    type: string
-    displayType: string
-    result: string
-    global: boolean
-    autoEnter: boolean
-    fourDigitYear: boolean
-    maxRepeat: number
-    maxCharacters: number
-    notEmpty: boolean
-    numeric: boolean
-    timeOfDay: false
-    repetitionStart: number
-    repetitionEnd: number
-}
-
-export interface LayoutMetaData {
-    fieldMetaData: FieldMetaData[]
-    portalMetaData?: Record<string, FieldMetaData[]>
-}
-
-export interface FMHostMetadata {
-    productInfo: {
-        buildDate: Date
-        name: string
-        version: string
-        dateFormat: string
-        timeFormat: string
-        timeStampFormat: string
-    }
-}
-
-export interface ScriptResult {
-    scriptError?: FMError
-    scriptResult?: string
-}
-
-export interface ContainerBufferResult {
-    buffer: Buffer
-    mime?: string
-    request: http.IncomingMessage
-}
-
-//
-// module.exports = {
-//     default: {FileMakerConnection}
-// }
-
-export interface AuthorizationHeaders {
-    'Content-Type': 'application/json'
-    Authorization: string
-}
-
-export interface AuthorizationHeadersOAuth {
-    'Content-Type': 'application/json'
-    'X-FM-Data-OAuth-RequestId': string
-    'X-FM-Data-OAuth-Identifier': string
-}
-
-export interface RecordFetchOptions {
-    readonly portals: readonly string[]
-}
-
-export enum RecordTypes {
-    UNKNOWN,
-    LAYOUT,
-    PORTAL
-}

package/src/utils/query.ts

@@ -1,59 +0,0 @@
-/*
- * Copyright (c) 2024. See LICENSE file for more information
- */
-
-import moment, {type Moment} from 'moment'
-
-export const FindRequestSymbol = Symbol('easyfm-findrequest')
-const SPECIAL_CHARACTERS = ['\\', '=', '<', '≤', '≥', '>', '…', '...', '//', '@', '#', '*', '"', '~']
-export interface TimestampType {
-    type: 'date' | 'time' | 'timestamp'
-    moment: Moment
-}
-type QueryParameter = string | number | TimestampType
-export interface Query { [FindRequestSymbol]: Array<string | TimestampType> }
-
-export function queryEscape (str: string) {
-    for (const char of SPECIAL_CHARACTERS) {
-        str = str.replace(char, `\\${char}`)
-    }
-    return str
-}
-
-export function query (strings: TemplateStringsArray, ...args: QueryParameter[]): Query {
-    const argStrings = args.map(item => {
-        if (typeof item === 'number') {
-            return queryEscape(item.toString())
-        } else if (typeof item === 'string') return queryEscape(item)
-        else return item
-    })
-
-    // Zip the parameters together
-    const query = strings.map((str, index) => {
-        return [str, (argStrings[index] || '')]
-    }).flat(1)
-    return {[FindRequestSymbol]: query}
-}
-
-export function asDate (date: Date | Moment): TimestampType {
-    return {
-        type: 'date',
-        moment: moment(date)
-    }
-}
-
-export function asTime (date: Date | Moment): TimestampType {
-    return {
-        type: 'time',
-        moment: moment(date)
-    }
-}
-
-export function asTimestamp (date: Date | Moment): TimestampType {
-    return {
-        type: 'timestamp',
-        moment: moment(date)
-    }
-}
-
-query