@jd-data-limited/easy-fm 5.0.0-beta.2 → 5.0.0-beta.5

package/dist/connection/DataApiProvider.js

@@ -0,0 +1,246 @@
+import { FMError } from '../FMError.js';
+import { FMHostMetadata } from '../types.js';
+import { ApiResults } from '../models/apiResults.js';
+import { CookieJar } from './CookieJar.js';
+import { generateAuthorizationHeaders } from './generateAuthorizationHeaders.js';
+import { addHeaders } from '../utils/addHeaders.js';
+import { ProviderSessionExpiredError } from './databaseProvider.js';
+export class DataApiProvider {
+    name;
+    formatting = { dateFormat: 'MM/DD/YYYY', timeFormat: 'HH:mm:ss', timeStampFormat: 'MM/DD/YYYY HH:mm:ss' };
+    #options;
+    #origin;
+    #endpoint;
+    constructor(options) {
+        const host = new URL(options.hostname);
+        if (host.protocol !== 'http:' && host.protocol !== 'https:')
+            throw new Error('hostname MUST begin with either http:// or https://');
+        this.#options = options;
+        this.name = options.database;
+        this.#origin = host.origin;
+        this.#endpoint = `${host.origin}/fmi/data/v2/databases/${encodeURIComponent(options.database)}`;
+    }
+    async connect(context) {
+        const response = await fetch(`${this.#origin}/fmi/data/v2/productInfo`, { signal: context.signal });
+        const raw = await response.json();
+        const parsed = ApiResults.extend({ response: FMHostMetadata.optional() }).parse(raw);
+        if (parsed.messages[0].code !== 0 || !parsed.response)
+            throw new FMError(parsed.messages[0].code, response.status, parsed);
+        const info = parsed.response.productInfo;
+        Object.assign(this.formatting, {
+            dateFormat: info.dateFormat.replace('dd', 'DD').replace('yyyy', 'YYYY'),
+            timeFormat: info.timeFormat,
+            timeStampFormat: info.timeStampFormat.replace('dd', 'DD').replace('yyyy', 'YYYY')
+        });
+        const credentials = this.#options.credentials;
+        const maxSessions = credentials.method === 'filemaker' ? credentials.sessionPoolSize ?? 8 : 1;
+        return {
+            formatting: this.formatting,
+            maxSessions,
+            openSession: async (signal) => await this.#openSession(signal, context.debug || this.#options.debug === true)
+        };
+    }
+    async #openSession(signal, debug) {
+        const credentials = this.#options.credentials;
+        if (this.#options.externalSources.length && credentials.method !== 'filemaker') {
+            throw new Error("External sources are only supported with the 'filemaker' login method");
+        }
+        if (credentials.method === 'token')
+            return new DataApiSession(this.#endpoint, credentials.token, new CookieJar(), signal, debug, false);
+        const url = new URL(`${this.#endpoint}/sessions`);
+        const jar = new CookieJar();
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: generateAuthorizationHeaders(credentials),
+            body: JSON.stringify({ fmDataSource: this.#options.externalSources.map(source => ({ database: source.database, username: source.credentials.username, password: source.credentials.password })) }),
+            signal
+        });
+        for (const cookie of response.headers.getSetCookie())
+            jar.addCookie(url, cookie);
+        const raw = await response.json();
+        const parsed = ApiResults.parse(raw);
+        if (!response.ok || parsed.messages[0].code !== 0)
+            throw new FMError(parsed.messages[0].code, response.status, parsed);
+        return new DataApiSession(this.#endpoint, response.headers.get('x-fm-data-access-token') ?? '', jar, signal, debug, true);
+    }
+}
+class DataApiSession {
+    endpoint;
+    token;
+    cookies;
+    databaseSignal;
+    debug;
+    ownsToken;
+    #closed = false;
+    constructor(endpoint, token, cookies, databaseSignal, debug, ownsToken) {
+        this.endpoint = endpoint;
+        this.token = token;
+        this.cookies = cookies;
+        this.databaseSignal = databaseSignal;
+        this.debug = debug;
+        this.ownsToken = ownsToken;
+    }
+    async execute(operation) {
+        let path;
+        let options = {};
+        switch (operation.type) {
+            case 'layout.list':
+                path = `/layouts?page=${encodeURIComponent(operation.page)}`;
+                break;
+            case 'layout.metadata':
+                path = `/layouts/${encodeURIComponent(operation.layout)}`;
+                break;
+            case 'script.run':
+                path = `/layouts/${encodeURIComponent(operation.layout)}/script/${encodeURIComponent(operation.script)}`;
+                if (operation.parameter)
+                    path += `?script.param=${encodeURIComponent(operation.parameter)}`;
+                break;
+            case 'record.list': {
+                const request = operation.options;
+                if (!operation.query.length) {
+                    const params = new URLSearchParams({ _limit: String(request.limit), _offset: String(request.offset), dateformats: '2', portal: JSON.stringify(Object.keys(request.portals)) });
+                    if (request.sort.length)
+                        params.set('_sort', JSON.stringify(request.sort));
+                    addScriptParams(params, request.scripts);
+                    addPortalParams(params, request.portals);
+                    path = `/layouts/${encodeURIComponent(operation.layout)}/records?${params}`;
+                }
+                else {
+                    const body = { limit: String(request.limit), offset: String(request.offset), dateformats: 2, query: operation.query.map(clause => ({ ...clause.fields, ...(clause.omit ? { omit: 'true' } : {}) })), portal: Object.keys(request.portals) };
+                    if (request.sort.length)
+                        body.sort = request.sort;
+                    addScriptBody(body, request.scripts);
+                    addPortalBody(body, request.portals);
+                    path = `/layouts/${encodeURIComponent(operation.layout)}/_find`;
+                    options = { method: 'POST', body: JSON.stringify(body) };
+                }
+                break;
+            }
+            case 'record.get':
+                path = `/layouts/${encodeURIComponent(operation.layout)}/records/${operation.recordId}?${recordParams(operation.options)}`;
+                break;
+            case 'record.create':
+                path = `/layouts/${encodeURIComponent(operation.layout)}/records`;
+                options = { method: 'POST', body: JSON.stringify(recordBody(operation.body, operation.options)) };
+                break;
+            case 'record.update':
+                path = `/layouts/${encodeURIComponent(operation.layout)}/records/${operation.recordId}`;
+                options = { method: 'PATCH', body: JSON.stringify(recordBody(operation.body, operation.options)) };
+                break;
+            case 'record.duplicate':
+                path = `/layouts/${encodeURIComponent(operation.layout)}/records/${operation.recordId}?${recordParams(operation.options)}`;
+                options = { method: 'POST' };
+                break;
+            case 'record.delete':
+                path = `/layouts/${encodeURIComponent(operation.layout)}/records/${operation.recordId}?${recordParams(operation.options)}`;
+                options = { method: 'DELETE' };
+                break;
+            case 'container.upload': {
+                path = `/layouts/${encodeURIComponent(operation.layout)}/records/${operation.recordId}/containers/${encodeURIComponent(operation.field)}/1`;
+                const form = new FormData();
+                form.append('upload', operation.file);
+                options = { method: 'POST', body: form };
+                break;
+            }
+        }
+        if (operation.type !== 'container.upload')
+            addHeaders(options, { 'Content-Type': 'application/json' });
+        const { response, body } = await this.#requestJSON(`${this.endpoint}${path}`, options);
+        const value = normalize(operation, body.response, response.status);
+        return value;
+    }
+    async #requestJSON(url, options) {
+        const response = await this.#request(url, options);
+        const body = await response.json();
+        if (this.debug)
+            console.log(body.response);
+        const parsed = ApiResults.passthrough().parse(body);
+        if (parsed.messages[0].code !== 0)
+            throw new FMError(parsed.messages[0].code, response.status, parsed);
+        return { response, body: parsed };
+    }
+    async #request(input, init = {}) {
+        let url = new URL(input);
+        let options = { ...init };
+        options.signal = options.signal ? AbortSignal.any([options.signal, this.databaseSignal]) : this.databaseSignal;
+        for (let count = 0; count < 10; count++) {
+            const headers = new Headers(options.headers);
+            headers.set('Authorization', `Bearer ${this.token}`);
+            const cookie = this.cookies.getCookieHeader(url);
+            if (cookie)
+                headers.set('Cookie', cookie);
+            const response = await fetch(url, { ...options, headers, redirect: 'manual' });
+            for (const value of response.headers.getSetCookie())
+                this.cookies.addCookie(url, value);
+            if (response.status === 401)
+                throw new ProviderSessionExpiredError();
+            if (response.status >= 300 && response.status < 400) {
+                const location = response.headers.get('location');
+                if (!location)
+                    throw new Error(`Redirect response missing Location header for ${url}`);
+                url = new URL(location, url);
+                const method = (options.method ?? 'GET').toUpperCase();
+                if (response.status === 303 || ((response.status === 301 || response.status === 302) && method === 'POST'))
+                    options = { ...options, method: 'GET', body: undefined };
+                continue;
+            }
+            return response;
+        }
+        throw new Error(`Too many redirects while fetching ${url}`);
+    }
+    async fetchContainer(reference, signal) { return await this.#request(reference, { signal }); }
+    async close() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        if (!this.ownsToken)
+            return;
+        await fetch(`${this.endpoint}/sessions/${this.token}`, { method: 'DELETE' }).catch(() => { });
+    }
+}
+function normalize(operation, response, status) {
+    switch (operation.type) {
+        case 'layout.list': return flattenLayouts(response?.layouts ?? []);
+        case 'layout.metadata': return response;
+        case 'script.run': return { scriptError: Number(response?.scriptError ?? 0), scriptResult: response?.scriptResult, status };
+        case 'record.list': return response?.data ?? [];
+        case 'record.get': return response?.data?.[0];
+        case 'record.create':
+        case 'record.update':
+        case 'record.duplicate':
+        case 'record.delete': return { ...(response ?? {}), scriptError: response?.scriptError === undefined ? undefined : Number(response.scriptError), status };
+        case 'container.upload': return undefined;
+    }
+}
+function flattenLayouts(layouts) { return layouts.flatMap(item => item.folderLayoutNames ? flattenLayouts(item.folderLayoutNames) : [item.name]); }
+function recordParams(options) { const params = new URLSearchParams(); addScriptParams(params, options.scripts); addPortalParams(params, options.portals); return params; }
+function recordBody(body, options) {
+    const result = { ...body };
+    if (Array.isArray(result.deleteRelatedRecords)) {
+        result.fieldData = { ...(result.fieldData ?? {}), deleteRelated: result.deleteRelatedRecords.map((item) => `${item.table}.${item.recordId}`) };
+        delete result.deleteRelatedRecords;
+    }
+    addScriptBody(result, options.scripts);
+    return result;
+}
+function addScriptParams(params, scripts) { for (const [key, script] of Object.entries(scripts)) {
+    const name = key === 'after' ? 'script' : `script.${key}`;
+    params.set(name, script.name);
+    if (script.parameter)
+        params.set(`${name}.param`, script.parameter);
+} }
+function addScriptBody(body, scripts) { for (const [key, script] of Object.entries(scripts)) {
+    const name = key === 'after' ? 'script' : `script.${key}`;
+    body[name] = script.name;
+    if (script.parameter)
+        body[`${name}.param`] = script.parameter;
+} }
+function addPortalParams(params, portals) { const names = Object.keys(portals); if (names.length)
+    params.set('portal', JSON.stringify(names)); for (const [name, page] of Object.entries(portals)) {
+    params.set(`_offset.${name}`, String(page.offset));
+    params.set(`_limit.${name}`, String(page.limit));
+} }
+function addPortalBody(body, portals) { for (const [name, page] of Object.entries(portals)) {
+    body[`offset.${name}`] = page.offset;
+    body[`limit.${name}`] = page.limit;
+} }

package/dist/connection/dataApiDatabaseSession.d.ts

@@ -0,0 +1,11 @@
+import type { DatabaseOperation, DatabaseOperationResult, DatabaseExecutor } from './databaseProvider.js';
+import type { Session } from './Session.js';
+/** Maps transport-neutral database operations onto FileMaker Data API HTTP. */
+export declare class DataApiDatabaseSession implements DatabaseExecutor {
+    private readonly endpoint;
+    private readonly session;
+    private readonly debug;
+    constructor(endpoint: string, session: Session, debug?: boolean);
+    execute(operation: DatabaseOperation): Promise<DatabaseOperationResult>;
+    downloadContainer(url: string | URL, signal?: AbortSignal): Promise<Response>;
+}

package/dist/connection/dataApiDatabaseSession.js

@@ -0,0 +1,139 @@
+import { addHeaders } from '../utils/addHeaders.js';
+/** Maps transport-neutral database operations onto FileMaker Data API HTTP. */
+export class DataApiDatabaseSession {
+    endpoint;
+    session;
+    debug;
+    constructor(endpoint, session, debug = false) {
+        this.endpoint = endpoint;
+        this.session = session;
+        this.debug = debug;
+    }
+    async execute(operation) {
+        let url;
+        let options = {};
+        switch (operation.type) {
+            case 'layout.list':
+                url = `${this.endpoint}/layouts?page=${encodeURIComponent(operation.page)}`;
+                break;
+            case 'layout.metadata':
+                url = `${this.endpoint}/layouts/${encodeURIComponent(operation.layout)}`;
+                break;
+            case 'script.run':
+                url = `${this.endpoint}/layouts/${encodeURIComponent(operation.layout)}/script/${encodeURIComponent(operation.script)}`;
+                if (operation.parameter)
+                    url += `?script.param=${encodeURIComponent(operation.parameter)}`;
+                break;
+            case 'record.list': {
+                const request = operation.options;
+                if (operation.query.length === 0) {
+                    const params = new URLSearchParams({
+                        _limit: request.limit.toString(),
+                        _offset: request.offset.toString(),
+                        dateformats: '2',
+                        portal: JSON.stringify(Object.keys(request.portals))
+                    });
+                    if (request.sort.length)
+                        params.set('_sort', JSON.stringify(request.sort));
+                    addScriptParams(params, request.scripts);
+                    for (const [portal, paging] of Object.entries(request.portals)) {
+                        params.set(`_offset.${portal}`, paging.offset.toString());
+                        params.set(`_limit.${portal}`, paging.limit.toString());
+                    }
+                    url = `${this.endpoint}/layouts/${encodeURIComponent(operation.layout)}/records?${params}`;
+                }
+                else {
+                    const body = {
+                        limit: request.limit.toString(),
+                        offset: request.offset.toString(),
+                        dateformats: 2,
+                        query: operation.query.map(clause => ({
+                            ...clause.fields,
+                            ...(clause.omit ? { omit: 'true' } : {})
+                        })),
+                        portal: Object.keys(request.portals)
+                    };
+                    if (request.sort.length)
+                        body.sort = request.sort;
+                    addScriptBody(body, request.scripts);
+                    for (const [portal, paging] of Object.entries(request.portals)) {
+                        body[`offset.${portal}`] = paging.offset;
+                        body[`limit.${portal}`] = paging.limit;
+                    }
+                    url = `${this.endpoint}/layouts/${encodeURIComponent(operation.layout)}/_find`;
+                    options = { method: 'POST', body: JSON.stringify(body) };
+                }
+                break;
+            }
+            case 'record.get':
+                url = `${this.endpoint}/layouts/${encodeURIComponent(operation.layout)}/records/${operation.recordId}?${recordParams(operation.options)}`;
+                break;
+            case 'record.create':
+                url = `${this.endpoint}/layouts/${encodeURIComponent(operation.layout)}/records`;
+                options = { method: 'POST', body: JSON.stringify(recordBody(operation.body, operation.options)) };
+                break;
+            case 'record.update':
+                url = `${this.endpoint}/layouts/${encodeURIComponent(operation.layout)}/records/${operation.recordId}`;
+                options = { method: 'PATCH', body: JSON.stringify(recordBody(operation.body, operation.options)) };
+                break;
+            case 'record.duplicate':
+                url = `${this.endpoint}/layouts/${encodeURIComponent(operation.layout)}/records/${operation.recordId}?${recordParams(operation.options)}`;
+                options = { method: 'POST' };
+                break;
+            case 'record.delete':
+                url = `${this.endpoint}/layouts/${encodeURIComponent(operation.layout)}/records/${operation.recordId}?${recordParams(operation.options)}`;
+                options = { method: 'DELETE' };
+                break;
+            case 'container.upload': {
+                url = `${this.endpoint}/layouts/${encodeURIComponent(operation.layout)}/records/${operation.recordId}/containers/${encodeURIComponent(operation.field)}/1`;
+                const form = new FormData();
+                form.append('upload', operation.file);
+                options = { method: 'POST', body: form };
+                break;
+            }
+        }
+        if (operation.type !== 'container.upload')
+            addHeaders(options, { 'Content-Type': 'application/json' });
+        const response = await this.session.fetch(url, options);
+        const body = await response.json();
+        if (this.debug)
+            console.log(body.response);
+        return { body, status: response.status };
+    }
+    async downloadContainer(url, signal) {
+        return await this.session.fetch(url, { signal });
+    }
+}
+function recordParams(options) {
+    const params = new URLSearchParams();
+    addScriptParams(params, options.scripts);
+    const portals = Object.keys(options.portals);
+    if (portals.length)
+        params.set('portal', JSON.stringify(portals));
+    for (const [portal, paging] of Object.entries(options.portals)) {
+        params.set(`_offset.${portal}`, paging.offset.toString());
+        params.set(`_limit.${portal}`, paging.limit.toString());
+    }
+    return params;
+}
+function recordBody(body, options) {
+    const result = body && typeof body === 'object' ? { ...body } : {};
+    addScriptBody(result, options.scripts);
+    return result;
+}
+function addScriptParams(params, scripts) {
+    for (const [key, script] of Object.entries(scripts)) {
+        const apiKey = key === 'after' ? 'script' : `script.${key}`;
+        params.set(apiKey, script.name);
+        if (script.parameter)
+            params.set(`${apiKey}.param`, script.parameter);
+    }
+}
+function addScriptBody(body, scripts) {
+    for (const [key, script] of Object.entries(scripts)) {
+        const apiKey = key === 'after' ? 'script' : `script.${key}`;
+        body[apiKey] = script.name;
+        if (script.parameter)
+            body[`${apiKey}.param`] = script.parameter;
+    }
+}

package/dist/connection/database.d.ts

@@ -1,70 +1,36 @@
-import { type LayoutInterface } from '../layouts/layoutInterface.js';
 import { Layout } from '../layouts/layout.js';
-import { type databaseOptionsWithExternalSources, type Script } from '../types.js';
-import { type HostBase } from './HostBase.js';
-import { type DatabaseBase } from './databaseBase.js';
-import { type DatabaseStructure } from '../databaseStructure.js';
-import { type DatabaseEndpoint, type Session } from './Session.js';
-import { z, type ZodType } from 'zod';
-/**
- * Represents a database connection.
- * @template T - The structure of the database.
- */
-export declare abstract class Database<T extends DatabaseStructure> implements DatabaseBase {
+import type { LayoutInterface } from '../layouts/layoutInterface.js';
+import type { DatabaseStructure } from '../databaseStructure.js';
+import type { Script } from '../types.js';
+import type { DatabaseBase } from './databaseBase.js';
+import { type DatabaseOperation, type DatabaseOperationResult, type DatabaseOperationType, type DatabaseProvider, type SessionBinding } from './databaseProvider.js';
+export interface DatabaseOptions {
+    provider: DatabaseProvider;
+    name?: string;
+    debug?: boolean;
+}
+export declare class Database<T extends DatabaseStructure> implements DatabaseBase {
     #private;
-    readonly host: HostBase;
     readonly name: string;
     readonly debug: boolean;
-    protected canOpenNewConnections: boolean;
-    /**
-     * Used during events where the application must logout
-     * @private
-     */
-    protected abortController: AbortController;
-    protected constructor(host: HostBase, conn: databaseOptionsWithExternalSources<unknown>);
+    private constructor();
+    static create<T extends DatabaseStructure = DatabaseStructure>(options: DatabaseOptions): Database<T>;
+    connect(): Promise<void>;
+    get dateFormat(): string;
+    get timeFormat(): string;
+    get timeStampFormat(): string;
+    execute<K extends DatabaseOperationType>(operation: DatabaseOperation<K>): Promise<{
+        value: DatabaseOperationResult<K>;
+        binding: SessionBinding;
+    }>;
+    fetchContainer(reference: string, binding: SessionBinding, signal?: AbortSignal): Promise<Response>;
     login(): Promise<void>;
     logout(): Promise<void>;
     close(): Promise<void>;
     [Symbol.asyncDispose](): Promise<void>;
-    /**
-     * The inheriting database class must implement this method to provide a session object.
-     * @param callback
-     * @protected
-     */
-    protected abstract withSession<T>(callback: (session: Session) => Promise<T>): Promise<T>;
-    /**
-     * Returns the endpoint URL for the database connection.
-     *
-     * @returns {string} The endpoint URL.
-     */
-    get endpoint(): DatabaseEndpoint;
-    /**
-     * Uses an available session to run a fetch
-     * @param url
-     * @param options
-     */
-    fetch(url: string | URL, options?: RequestInit): Promise<Response>;
-    /**
-     * Uses an available session to run a fetch on a FileMaker Data API JSON endpoint. Also applies JSON/Zod type enforcement on result.
-     */
-    fetchJSON<T extends ZodType | null = null>(url: string | URL, options: RequestInit & {
-        type: T;
-    }): Promise<T extends ZodType ? z.infer<T> & {
-        httpStatus: number;
-    } : {
-        httpStatus: number;
-    }>;
-    /**
-     * 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.
-     */
     listLayouts(page?: number): Promise<Layout<LayoutInterface>[]>;
     layout<R extends keyof T['layouts']>(name: R): Layout<T['layouts'][R]>;
     layout<R extends LayoutInterface>(name: string): Layout<R>;
-    /** Clears any Layout objects previously returned by `database.layout(...)`. */
     clearLayoutCache(): void;
-    /** Creates a script reference you can pass to read and write helpers. */
     script(name: string, parameter?: string): Script;
 }