@kaspernj/api-maker 1.0.2171 → 1.0.2173

package/build/commands-pool.d.ts

@@ -44,6 +44,42 @@ export default class ApiMakerCommandsPool {
         commandSubmitData: CommandSubmitData;
         commandExecution?: ApiMakerCommandExecution;
     }): Promise<CommandsRequestResponse>;
+    /**
+     * Performs a single command request over websocket or HTTP.
+     * @param {object} args
+     * @param {string} args.url
+     * @param {CommandSubmitData} args.commandSubmitData
+     * @param {ApiMakerCommandExecution} [args.commandExecution]
+     * @returns {Promise<CommandsRequestResponse>}
+     */
+    performRequest({ commandExecution, commandSubmitData, url }: {
+        url: string;
+        commandSubmitData: CommandSubmitData;
+        commandExecution?: ApiMakerCommandExecution;
+    }): Promise<CommandsRequestResponse>;
+    /**
+     * The user ids the frontend believes it is signed in as, keyed by Devise
+     * scope. Sent with each request so the backend can detect (and let the
+     * frontend recover from) a stale session before running commands. Undefined
+     * when nothing is signed in, so genuinely anonymous requests send no belief.
+     * @returns {Record<string, number | string> | undefined}
+     */
+    believedDeviseUserIds(): Record<string, number | string> | undefined;
+    /**
+     * The global request data merged with the believed signed-in identity.
+     * @returns {Record<string, unknown>}
+     */
+    globalDataForRequest(): Record<string, unknown>;
+    /**
+     * Recovers from an `authentication_changed` response: refreshes the existing
+     * websocket connection's auth in-place from the current server session (no
+     * reconnect, no password) and reconciles the local session cache. Returns
+     * whether a previously signed-in scope is still authenticated, so the request
+     * can be retried; false means the user is genuinely signed out (the sign-in
+     * form is shown centrally via the Devise sign-out event).
+     * @returns {Promise<boolean>}
+     */
+    recoverAuthentication(): Promise<boolean>;
     /** Sends the currently queued commands and resolves or rejects their executions. */
     flush: () => Promise<void>;
     /**
@@ -119,6 +155,109 @@ export type PoolDataType = {
         };
     };
 };
+export type BaseModelWithId = {
+    abilities: import("./base-model.js").ModelAbilityMap;
+    changes: import("./base-model.js").ModelDataMap;
+    collection: import("./collection.js").default<any>;
+    _identifierKey: string | number;
+    _markedForDestruction: boolean;
+    modelData: import("./base-model.js").ModelDataMap;
+    newRecord: boolean;
+    previousModelData: any;
+    preloadedRelationships: import("./base-model.js").PreloadedRelationshipMap;
+    relationshipsCache: import("./base-model.js").LoadedRelationshipMap;
+    relationships: import("./base-model.js").LoadedRelationshipMap;
+    uniqueKeyValue: number;
+    assignAttributes(newAttributes: ModelDataMap): void;
+    attributes(): ModelDataMap;
+    can(givenAbilityName: string): boolean;
+    clone(): /*elided*/ any;
+    cacheKey(): number | string;
+    localCacheKey(): string;
+    fullCacheKey(): string;
+    create(attributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+        model: /*elided*/ any;
+        response: ModelCommandResponse;
+    }>;
+    createRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions): Promise<{
+        model: /*elided*/ any;
+        response: ModelCommandResponse;
+    }>;
+    destroy(): Promise<{
+        model: /*elided*/ any;
+        response: ModelCommandResponse;
+    }>;
+    ensureAbilities(listOfAbilities: string[]): Promise<void>;
+    getAttributes(): ModelDataMap;
+    handleResponseError(response: ModelCommandResponse): never;
+    identifierKey(): number | string;
+    isAssociationLoaded(associationName: string): boolean;
+    isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
+    isAssociationPresent(associationName: string): boolean;
+    ensureAssociationLoaded(associationName: string): Promise<LoadedRelationshipValue>;
+    ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<LoadedRelationshipValue>;
+    isAttributeChanged(attributeName: string): boolean;
+    isChanged(): boolean;
+    isNewRecord(): boolean;
+    isPersisted(): boolean;
+    savedChangeToAttribute(attributeName: string): boolean;
+    setNewModel(model: /*elided*/ any): void;
+    setNewModelData(model: /*elided*/ any): void;
+    _isDateChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+    _isIntegerChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+    _isStringChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+    modelClassData(): ModelClassDataType;
+    reload(): Promise<void>;
+    save(): Promise<{
+        model: /*elided*/ any;
+        response?: object;
+    }>;
+    saveRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+        simpleModelErrors?: boolean;
+    }): Promise<{
+        model: /*elided*/ any;
+        response: ModelCommandResponse;
+    }>;
+    update(newAttributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+        model: /*elided*/ any;
+        response?: object;
+    }>;
+    _refreshModelFromResponse(response: ModelCommandResponse): void;
+    _refreshModelDataFromResponse(response: ModelCommandResponse): void;
+    updateRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+        simpleModelErrors?: boolean;
+    }): Promise<{
+        response: ModelCommandResponse;
+        model: /*elided*/ any;
+    }>;
+    isValid(): never;
+    isValidOnServer(): Promise<{
+        valid: boolean;
+        errors: ValidationResponseErrors;
+    }>;
+    modelClass(): BaseModelClassType;
+    preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
+    markForDestruction(): void;
+    markedForDestruction(): boolean;
+    uniqueKey(): number;
+    _callMemberCommand(args: ModelCommandDescriptor, commandArgs: ModelCommandOptions): import("./command-execution.js").default;
+    readAttribute(attributeName: string): ModelValue | null | undefined;
+    readAttributeUnderscore(attributeName: string): ModelValue | null | undefined;
+    isAttributeLoaded(attributeName: string): boolean;
+    _isPresent(value: ModelValue | null | undefined): boolean;
+    _loadBelongsToReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any | null>;
+    _readBelongsToReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+    _loadHasManyReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any[]>;
+    _loadHasOneReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any | null>;
+    _readHasOneReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+    _readModelDataFromArgs(args?: BaseModelArgsObject): void;
+    _readPreloadedRelationships(preloaded: {
+        getModel: (relationshipType: string, relationshipId: number | string) => /*elided*/ any;
+    }): void;
+    primaryKey(): number | string;
+} & {
+    id: () => number | string;
+};
 import ApiMakerCommandExecution from "./command-execution.js";
 import CommandSubmitData from "./command-submit-data.js";
 import RunLast from "./run-last.js";

package/build/commands-pool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"commands-pool.d.ts","sourceRoot":"/src/","sources":["commands-pool.js"],"names":[],"mappings":"AAkEA,4EAA4E;AAC5E;IACE;;;;;OAKG;IACH,wBAJW,iBAAiB,SACjB,qBAAqB,GACnB,wBAAwB,CAuBpC;IAED;;;OAGG;IACH,kBAFa,oBAAoB,CAMhC;IAED,mDAAmD;IACnD,qBAEC;IAIC,mBAAmB;IAEnB,8CAA8C;IAC9C,MADW,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAC5B;IAEd,2BAA2B;IAC3B,UADW,YAAY,CACL;IAElB,kBAAkB;IAElB,iCAAiC;IACjC,mBADW,kBAAkB,CACF;IAE3B,oCAAoC;IACpC,gBADW,qBAAqB,CACR;IAG1B;;;;OAIG;IACH,iBAHW,iBAAiB,GACf,wBAAwB,CAoCpC;IAED,wBAAwB;IACxB,iBADc,MAAM,CAGnB;IAED;;;;;;OAMG;IACH,0DALG;QAAqB,GAAG,EAAhB,MAAM;QACkB,iBAAiB,EAAzC,iBAAiB;QACe,gBAAgB,GAAhD,wBAAwB;KAChC,GAAU,OAAO,CAAC,uBAAuB,CAAC,CAiC5C;IAED,oFAAoF;IACpF,2BAkDC;IAED;;;;OAIG;IACH,kCAJW,eAAe,uBACf,yBAAyB,GACvB,OAAO,CAAC,IAAI,CAAC,CAwBzB;IAED;;;;;;OAMG;IACH,mCAJW,eAAe,SACf,KAAK,GACH,IAAI,CAkBhB;IAED;;;OAGG;IACH,0DAHW,yBAAyB,GACvB,OAAO,CAAC,IAAI,CAAC,CAgBzB;IAED;;;OAGG;IACH,YAFa,OAAO,CAYnB;IAED,sBAAsC;CACvC;4CArVa,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS;mCACrD,6BAA6B,GAAG,IAAI,GAAG,QAAQ,GAAG,eAAe,GAAG,6BAA6B,EAAE;iCACnG,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC;;WAGpC,oBAAoB;oBACpB,MAAM;aACN,MAAM;iBACN,MAAM,GAAG,MAAM;UACf,MAAM;;;oBAIN,OAAO;gBACP,OAAO;cACP,OAAO;;;UAIP,kBAAkB;UAClB,SAAS,GAAG,OAAO,GAAG,QAAQ;;;eAI9B,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAAC;cACvC,OAAO;WACP,MAAM;;;gBAIN,MAAM;aACN,MAAM,EAAE;wBACR,MAAM,EAAE;YACR,kBAAkB;;;sBAKlB,wBAAwB;WACxB,MAAM;;2BAGN;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG;YAAC,CAAC,GAAG,EAAE,MAAM,GAAG;gBAAC,CAAC,GAAG,EAAE,MAAM,GAAG;oBAAC,IAAI,EAAE,MAAM,CAAC;oBAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAAC;oBAAC,EAAE,EAAE,MAAM,CAAA;iBAAC,CAAA;aAAC,CAAA;SAAC,CAAA;KAAC,CAAA;CAAC;qCA3DrG,wBAAwB;8BAC/B,0BAA0B;oBASpC,eAAe"}
+{"version":3,"file":"commands-pool.d.ts","sourceRoot":"/src/","sources":["commands-pool.js"],"names":[],"mappings":"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"}

package/build/commands-pool.js

@@ -12,6 +12,7 @@ import events from "./events.js";
 import FormDataObjectizer from "form-data-objectizer"; // eslint-disable-line sort-imports
 import RunLast from "./run-last.js";
 import Serializer from "./serializer.js";
+import SessionExpiredError from "./session-expired-error.js";
 import SessionStatusUpdater from "./session-status-updater.js";
 import ValidationError from "./validation-error.js";
 import { ValidationErrors } from "./validation-errors.js";
@@ -57,6 +58,7 @@ import WebsocketRequestClient from "./websocket-request-client.js";
  * @property {string} stack
  */
 /** @typedef {{[key: string]: {[key: string]: {[key: string]: {[key: number]: {args: object, primary_key: number | string, id: number}}}}}} PoolDataType */
+/** @typedef {import("./base-model.js").default & {id: () => number | string}} BaseModelWithId */
 const shared = {};
 /** Batches command submissions and flushes them over HTTP or websockets. */
 export default class ApiMakerCommandsPool {
@@ -162,32 +164,89 @@ export default class ApiMakerCommandsPool {
      * @returns {Promise<CommandsRequestResponse>}
      */
     async sendRequest({ commandExecution, commandSubmitData, url }) {
+        for (let attempt = 0; attempt < 3; attempt++) {
+            const response = await this.performRequest({ commandExecution, commandSubmitData, url }); // eslint-disable-line no-await-in-loop
+            if (response?.success === false && response.type == "invalid_authenticity_token") {
+                console.log("Invalid authenticity token - try again");
+                await SessionStatusUpdater.current().updateSessionStatus(); // eslint-disable-line no-await-in-loop
+                continue; // eslint-disable-line no-continue
+            }
+            if (response?.success === false && response.type == "authentication_changed") {
+                const recovered = await this.recoverAuthentication(); // eslint-disable-line no-await-in-loop
+                if (recovered)
+                    continue; // eslint-disable-line no-continue
+                throw new SessionExpiredError();
+            }
+            return /** @type {CommandsRequestResponse} */ (response);
+        }
+        throw new Error("Couldnt successfully execute request");
+    }
+    /**
+     * Performs a single command request over websocket or HTTP.
+     * @param {object} args
+     * @param {string} args.url
+     * @param {CommandSubmitData} args.commandSubmitData
+     * @param {ApiMakerCommandExecution} [args.commandExecution]
+     * @returns {Promise<CommandsRequestResponse>}
+     */
+    async performRequest({ commandExecution, commandSubmitData, url }) {
         if (Config.getWebsocketRequests() && !this.requestOptions.forceHttp && commandSubmitData.getFilesCount() == 0) {
             return /** @type {Promise<CommandsRequestResponse>} */ (WebsocketRequestClient.current().perform({
                 cacheResponse: this.requestOptions.cacheResponse,
-                global: this.globalRequestData,
+                global: this.globalDataForRequest(),
                 onLog: (message) => commandExecution?.addLog(message),
                 onProgress: (progressData) => commandExecution?.setProgress(progressData),
                 onReceived: (receivedData) => commandExecution?.setReceived(receivedData),
                 request: commandSubmitData.getJsonData()
             }));
         }
-        let response;
-        for (let i = 0; i < 3; i++) {
-            if (commandSubmitData.getFilesCount() > 0) {
-                response = await Api.requestLocal({ path: url, method: "POST", rawData: commandSubmitData.getFormData() }); // eslint-disable-line no-await-in-loop
-            }
-            else {
-                response = await Api.requestLocal({ path: url, method: "POST", data: commandSubmitData.getJsonData() }); // eslint-disable-line no-await-in-loop
-            }
-            if (response.success === false && response.type == "invalid_authenticity_token") {
-                console.log("Invalid authenticity token - try again");
-                await SessionStatusUpdater.current().updateSessionStatus(); // eslint-disable-line no-await-in-loop
-                continue; // eslint-disable-line no-continue
-            }
-            return /** @type {CommandsRequestResponse} */ (response);
+        if (commandSubmitData.getFilesCount() > 0) {
+            return /** @type {CommandsRequestResponse} */ (await Api.requestLocal({ path: url, method: "POST", rawData: commandSubmitData.getFormData() }));
         }
-        throw new Error("Couldnt successfully execute request");
+        return /** @type {CommandsRequestResponse} */ (await Api.requestLocal({ path: url, method: "POST", data: commandSubmitData.getJsonData() }));
+    }
+    /**
+     * The user ids the frontend believes it is signed in as, keyed by Devise
+     * scope. Sent with each request so the backend can detect (and let the
+     * frontend recover from) a stale session before running commands. Undefined
+     * when nothing is signed in, so genuinely anonymous requests send no belief.
+     * @returns {Record<string, number | string> | undefined}
+     */
+    believedDeviseUserIds() {
+        const believed = /** @type {Record<string, number | string>} */ ({});
+        for (const scope of Devise.registeredScopes()) {
+            const model = Devise.current().getCurrentScope(scope);
+            if (model)
+                believed[scope] = /** @type {BaseModelWithId} */ (model).id();
+        }
+        return Object.keys(believed).length > 0 ? believed : undefined;
+    }
+    /**
+     * The global request data merged with the believed signed-in identity.
+     * @returns {Record<string, unknown>}
+     */
+    globalDataForRequest() {
+        const believed = this.believedDeviseUserIds();
+        if (!believed)
+            return this.globalRequestData;
+        return { ...this.globalRequestData, believed_devise_user_ids: believed };
+    }
+    /**
+     * Recovers from an `authentication_changed` response: refreshes the existing
+     * websocket connection's auth in-place from the current server session (no
+     * reconnect, no password) and reconciles the local session cache. Returns
+     * whether a previously signed-in scope is still authenticated, so the request
+     * can be retried; false means the user is genuinely signed out (the sign-in
+     * form is shown centrally via the Devise sign-out event).
+     * @returns {Promise<boolean>}
+     */
+    async recoverAuthentication() {
+        const sessionStatusUpdater = SessionStatusUpdater.current();
+        const sessionStatus = await sessionStatusUpdater.sessionStatus();
+        const scopes = Devise.registeredScopes();
+        await Promise.all(scopes.map((scope) => Devise.refreshWebsocketSession({ scope, shadowSessionToken: sessionStatus?.shadow_session_token })));
+        sessionStatusUpdater.applyResult(sessionStatus);
+        return scopes.some((scope) => Boolean(sessionStatus?.scopes?.[scope]?.signed_in));
     }
     /** Sends the currently queued commands and resolves or rejects their executions. */
     flush = async () => {
@@ -201,8 +260,9 @@ export default class ApiMakerCommandsPool {
         this.flushCount++;
         try {
             const submitData = { pool: currentPoolData };
-            if (Object.keys(this.globalRequestData).length > 0)
-                submitData.global = this.globalRequestData;
+            const globalData = this.globalDataForRequest();
+            if (Object.keys(globalData).length > 0)
+                submitData.global = globalData;
             const commandSubmitData = new CommandSubmitData(submitData);
             const url = "/api_maker/commands";
             const commandExecution = Object.values(currentPool)[0]?.commandExecution;
@@ -232,6 +292,15 @@ export default class ApiMakerCommandsPool {
                 }
             }));
         }
+        catch (error) {
+            // sendRequest (e.g. an unrecoverable SessionExpiredError) or response
+            // handling can throw before the per-command promises are settled. Reject
+            // every queued command so callers awaiting their execution don't hang
+            // forever. Already-settled executions ignore the extra reject.
+            for (const commandData of Object.values(currentPool)) {
+                commandData.commandExecution.reject(/** @type {Error} */ (error));
+            }
+        }
         finally {
             this.flushCount--;
         }
@@ -314,4 +383,4 @@ export default class ApiMakerCommandsPool {
     }
     flushRunLast = new RunLast(this.flush);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"commands-pool.js","sourceRoot":"/src/","sources":["commands-pool.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport Api from \"./api.js\"\nimport ApiMakerCommandExecution from \"./command-execution.js\"\nimport CommandSubmitData from \"./command-submit-data.js\"\nimport Config from \"./config.js\"\nimport CustomError from \"./custom-error.js\"\nimport DestroyError from \"./destroy-error.js\"\nimport Deserializer from \"./deserializer.js\" // eslint-disable-line sort-imports\nimport Devise from \"./devise.js\"\nimport {dig, digg} from \"diggerize\" // eslint-disable-line sort-imports\nimport events from \"./events.js\"\nimport FormDataObjectizer from \"form-data-objectizer\" // eslint-disable-line sort-imports\nimport RunLast from \"./run-last.js\"\nimport Serializer from \"./serializer.js\"\nimport SessionStatusUpdater from \"./session-status-updater.js\"\nimport ValidationError from \"./validation-error.js\"\nimport {ValidationErrors} from \"./validation-errors.js\"\nimport WebsocketRequestClient from \"./websocket-request-client.js\"\n\n/** @typedef {object | string | number | boolean | null | undefined} CommandArgumentScalarOrObject */\n/** @typedef {CommandArgumentScalarOrObject | File | FormData | HTMLFormElement | CommandArgumentScalarOrObject[]} CommandArgumentValue */\n/** @typedef {Record<string, CommandArgumentValue>} CommandArgumentMap */\n/**\n * @typedef {object} CommandDescriptor\n * @property {CommandArgumentValue} [args]\n * @property {string} collectionName\n * @property {string} command\n * @property {number | string} [primaryKey]\n * @property {string} type\n */\n/**\n * @typedef {object} CommandRequestOptions\n * @property {boolean} [cacheResponse]\n * @property {boolean} [forceHttp]\n * @property {boolean} [instant]\n */\n/**\n * @typedef {object} CommandResponseEnvelope\n * @property {CommandArgumentMap} data\n * @property {\"success\" | \"error\" | \"failed\"} type\n */\n/**\n * @typedef {object} CommandsRequestResponse\n * @property {Record<string, CommandResponseEnvelope>} responses\n * @property {boolean} [success]\n * @property {string} [type]\n */\n/**\n * @typedef {object} FailedCommandResponseData\n * @property {string} error_type\n * @property {string[]} [errors]\n * @property {string[]} [validation_errors]\n * @property {CommandArgumentMap} [model]\n */\n\n/**\n * @typedef {object} CommandDataType\n * @property {ApiMakerCommandExecution} commandExecution\n * @property {string} stack\n */\n\n/** @typedef {{[key: string]: {[key: string]: {[key: string]: {[key: number]: {args: object, primary_key: number | string, id: number}}}}}} PoolDataType */\n\nconst shared = {}\n\n/** Batches command submissions and flushes them over HTTP or websockets. */\nexport default class ApiMakerCommandsPool {\n  /**\n   * Adds a command to the shared or one-off command pool and schedules a flush.\n   * @param {CommandDescriptor} data\n   * @param {CommandRequestOptions} [args]\n   * @returns {ApiMakerCommandExecution}\n   */\n  static addCommand(data, args = {}) {\n    let pool\n    const useWebsocketRequests = Config.getWebsocketRequests()\n\n    if (args.instant || useWebsocketRequests) {\n      pool = new ApiMakerCommandsPool()\n      pool.globalRequestData = {...ApiMakerCommandsPool.current().globalRequestData}\n      pool.requestOptions = {...args}\n    } else {\n      pool = ApiMakerCommandsPool.current()\n    }\n\n    const promiseResult = pool.addCommand(data)\n\n    if (args.instant || useWebsocketRequests) {\n      pool.flushRunLast.run()\n    } else {\n      pool.flushRunLast.queue()\n    }\n\n    return promiseResult\n  }\n\n  /**\n   * Returns the shared command pool instance.\n   * @returns {ApiMakerCommandsPool}\n   */\n  static current() {\n    if (!shared.currentApiMakerCommandsPool) shared.currentApiMakerCommandsPool = new ApiMakerCommandsPool()\n\n    return shared.currentApiMakerCommandsPool\n  }\n\n  /** Flushes the shared command pool immediately. */\n  static flush() {\n    ApiMakerCommandsPool.current().flush()\n  }\n\n  /** Initializes one command pool instance with empty queued state. */\n  constructor() {\n    this.flushCount = 0\n\n    /** @type {Record<number, CommandDataType>} */\n    this.pool = {}\n\n    /** @type {PoolDataType} */\n    this.poolData = {}\n\n    this.currentId = 1\n\n    /** @type {CommandArgumentMap} */\n    this.globalRequestData = {}\n\n    /** @type {CommandRequestOptions} */\n    this.requestOptions = {}\n  }\n\n  /**\n   * Adds one command execution to this pool instance.\n   * @param {CommandDescriptor} data\n   * @returns {ApiMakerCommandExecution}\n   */\n  addCommand(data) {\n    const stack = Error().stack\n    const id = this.currentId\n    const commandExecution = new ApiMakerCommandExecution()\n    const commandType = data.type\n    const commandName = data.command\n    const collectionName = data.collectionName\n\n    this.currentId += 1\n    this.pool[id] = {commandExecution, stack}\n\n    if (!this.poolData[commandType]) this.poolData[commandType] = {}\n    if (!this.poolData[commandType][collectionName]) this.poolData[commandType][collectionName] = {}\n    if (!this.poolData[commandType][collectionName][commandName]) this.poolData[commandType][collectionName][commandName] = {}\n\n    let args\n\n    if (data.args?.nodeName == \"FORM\") {\n      const formData = new FormData(data.args)\n\n      args = FormDataObjectizer.toObject(formData)\n    } else if (data.args instanceof FormData) {\n      args = FormDataObjectizer.toObject(data.args)\n    } else {\n      args = Serializer.serialize(data.args)\n    }\n\n    this.poolData[commandType][collectionName][commandName][id] = {\n      args,\n      primary_key: data.primaryKey,\n      id\n    }\n\n    return commandExecution\n  }\n\n  /** @returns {number} */\n  commandsCount() {\n    return Object.keys(this.pool).length\n  }\n\n  /**\n   * @param {object} args\n   * @param {string} args.url\n   * @param {CommandSubmitData} args.commandSubmitData\n   * @param {ApiMakerCommandExecution} [args.commandExecution]\n   * @returns {Promise<CommandsRequestResponse>}\n   */\n  async sendRequest({commandExecution, commandSubmitData, url}) {\n    if (Config.getWebsocketRequests() && !this.requestOptions.forceHttp && commandSubmitData.getFilesCount() == 0) {\n      return /** @type {Promise<CommandsRequestResponse>} */ (WebsocketRequestClient.current().perform({\n        cacheResponse: this.requestOptions.cacheResponse,\n        global: this.globalRequestData,\n        onLog: (message) => commandExecution?.addLog(message),\n        onProgress: (progressData) => commandExecution?.setProgress(progressData),\n        onReceived: (receivedData) => commandExecution?.setReceived(receivedData),\n        request: commandSubmitData.getJsonData()\n      }))\n    }\n\n    let response\n\n    for (let i = 0; i < 3; i++) {\n      if (commandSubmitData.getFilesCount() > 0) {\n        response = await Api.requestLocal({path: url, method: \"POST\", rawData: commandSubmitData.getFormData()}) // eslint-disable-line no-await-in-loop\n      } else {\n        response = await Api.requestLocal({path: url, method: \"POST\", data: commandSubmitData.getJsonData()}) // eslint-disable-line no-await-in-loop\n      }\n\n      if (response.success === false && response.type == \"invalid_authenticity_token\") {\n        console.log(\"Invalid authenticity token - try again\")\n        await SessionStatusUpdater.current().updateSessionStatus() // eslint-disable-line no-await-in-loop\n        continue // eslint-disable-line no-continue\n      }\n\n      return /** @type {CommandsRequestResponse} */ (response)\n    }\n\n    throw new Error(\"Couldnt successfully execute request\")\n  }\n\n  /** Sends the currently queued commands and resolves or rejects their executions. */\n  flush = async () => {\n    if (this.commandsCount() == 0) {\n      return\n    }\n\n    const currentPool = this.pool\n    const currentPoolData = this.poolData\n\n    this.pool = {}\n    this.poolData = {}\n    this.flushCount++\n\n    try {\n      const submitData = {pool: currentPoolData}\n\n      if (Object.keys(this.globalRequestData).length > 0)\n        submitData.global = this.globalRequestData\n\n      const commandSubmitData = new CommandSubmitData(submitData)\n      const url = \"/api_maker/commands\"\n      const commandExecution = Object.values(currentPool)[0]?.commandExecution\n      const response = await this.sendRequest({commandExecution, commandSubmitData, url})\n\n      await Promise.all(Object.keys(response.responses).map(async(commandId) => {\n        const commandResponse = response.responses[commandId]\n        const commandResponseData = Deserializer.parse(commandResponse.data)\n        const commandData = currentPool[parseInt(commandId, 10)]\n        const responseType = commandResponse.type\n\n        if (commandResponseData && typeof commandResponseData == \"object\") {\n          const bugReportUrl = dig(commandResponseData, \"bug_report_url\")\n\n          if (bugReportUrl) {\n            console.log(`Bug report URL: ${bugReportUrl}`)\n          }\n        }\n\n        if (responseType == \"success\") {\n          commandData.commandExecution.resolve(commandResponseData)\n        } else if (responseType == \"error\") {\n          this.rejectWithCallerStack(commandData, new CustomError(\"Command error\", {response: commandResponseData}))\n        } else if (responseType == \"failed\") {\n          await this.handleFailedResponse(commandData, commandResponseData)\n        } else {\n          throw new Error(`Unhandled response type: ${responseType}`)\n        }\n      }))\n    } finally {\n      this.flushCount--\n    }\n  }\n\n  /**\n   * @param {CommandDataType} commandData\n   * @param {FailedCommandResponseData} commandResponseData\n   * @returns {Promise<void>}\n   */\n  async handleFailedResponse(commandData, commandResponseData) {\n    await this.refreshSessionStatusForNoAccessError(commandResponseData)\n\n    let error\n\n    if (commandResponseData.error_type == \"destroy_error\") {\n      error = new DestroyError(\"Destroy failed\", {response: commandResponseData})\n    } else if (commandResponseData.error_type == \"validation_error\") {\n      const validationErrors = new ValidationErrors({\n        model: digg(commandResponseData, \"model\"),\n        validationErrors: digg(commandResponseData, \"validation_errors\")\n      })\n      error = new ValidationError(validationErrors, {response: commandResponseData})\n\n      events.emit(\"onValidationErrors\", validationErrors)\n    } else {\n      const errorMessage = commandResponseData.errors ? undefined : \"Command failed\"\n\n      error = new CustomError(errorMessage, {response: commandResponseData})\n    }\n\n    this.rejectWithCallerStack(commandData, error)\n  }\n\n  /**\n   * Rejects the command with the given error, splicing the caller's stack (captured synchronously in addCommand) onto error.stack.\n   * Needed because error.stack is frozen at construction time inside flush()'s microtask and therefore loses the caller's frames.\n   * @param {CommandDataType} commandData\n   * @param {Error} error\n   * @returns {void}\n   */\n  rejectWithCallerStack(commandData, error) {\n    if (commandData.stack) {\n      // V8 prefixes \"Error\\n\" as a header; JSC/SpiderMonkey stacks start directly with a frame.\n      const callerFrames = commandData.stack.startsWith(\"Error\")\n        ? commandData.stack\n          .split(\"\\n\")\n          .slice(1)\n          .join(\"\\n\")\n        : commandData.stack\n\n      if (callerFrames) {\n        error.stack = `${error.stack ?? \"\"}\\n${callerFrames}`\n      }\n    }\n\n    commandData.commandExecution.reject(error)\n  }\n\n  /**\n   * @param {FailedCommandResponseData} commandResponseData\n   * @returns {Promise<void>}\n   */\n  async refreshSessionStatusForNoAccessError(commandResponseData) {\n    if (commandResponseData.error_type != \"not_found_or_no_access\") {\n      return\n    }\n\n    const signedInScope = Devise\n      .registeredScopes()\n      .find((scope) => Devise.current().hasCurrentScope(scope) || Devise.current().hasGlobalCurrentScope(scope))\n\n    if (!signedInScope) {\n      return\n    }\n\n    await SessionStatusUpdater.current().updateSessionStatus()\n  }\n\n  /**\n   * Returns true while one or more flushes are still in progress.\n   * @returns {boolean}\n   */\n  isActive() {\n    if (this.commandsCount() > 0) {\n      return true\n    }\n\n    if (this.flushCount > 0) {\n      return true\n    }\n\n    return false\n  }\n\n  flushRunLast = new RunLast(this.flush)\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"commands-pool.js","sourceRoot":"/src/","sources":["commands-pool.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport Api from \"./api.js\"\nimport ApiMakerCommandExecution from \"./command-execution.js\"\nimport CommandSubmitData from \"./command-submit-data.js\"\nimport Config from \"./config.js\"\nimport CustomError from \"./custom-error.js\"\nimport DestroyError from \"./destroy-error.js\"\nimport Deserializer from \"./deserializer.js\" // eslint-disable-line sort-imports\nimport Devise from \"./devise.js\"\nimport {dig, digg} from \"diggerize\" // eslint-disable-line sort-imports\nimport events from \"./events.js\"\nimport FormDataObjectizer from \"form-data-objectizer\" // eslint-disable-line sort-imports\nimport RunLast from \"./run-last.js\"\nimport Serializer from \"./serializer.js\"\nimport SessionExpiredError from \"./session-expired-error.js\"\nimport SessionStatusUpdater from \"./session-status-updater.js\"\nimport ValidationError from \"./validation-error.js\"\nimport {ValidationErrors} from \"./validation-errors.js\"\nimport WebsocketRequestClient from \"./websocket-request-client.js\"\n\n/** @typedef {object | string | number | boolean | null | undefined} CommandArgumentScalarOrObject */\n/** @typedef {CommandArgumentScalarOrObject | File | FormData | HTMLFormElement | CommandArgumentScalarOrObject[]} CommandArgumentValue */\n/** @typedef {Record<string, CommandArgumentValue>} CommandArgumentMap */\n/**\n * @typedef {object} CommandDescriptor\n * @property {CommandArgumentValue} [args]\n * @property {string} collectionName\n * @property {string} command\n * @property {number | string} [primaryKey]\n * @property {string} type\n */\n/**\n * @typedef {object} CommandRequestOptions\n * @property {boolean} [cacheResponse]\n * @property {boolean} [forceHttp]\n * @property {boolean} [instant]\n */\n/**\n * @typedef {object} CommandResponseEnvelope\n * @property {CommandArgumentMap} data\n * @property {\"success\" | \"error\" | \"failed\"} type\n */\n/**\n * @typedef {object} CommandsRequestResponse\n * @property {Record<string, CommandResponseEnvelope>} responses\n * @property {boolean} [success]\n * @property {string} [type]\n */\n/**\n * @typedef {object} FailedCommandResponseData\n * @property {string} error_type\n * @property {string[]} [errors]\n * @property {string[]} [validation_errors]\n * @property {CommandArgumentMap} [model]\n */\n\n/**\n * @typedef {object} CommandDataType\n * @property {ApiMakerCommandExecution} commandExecution\n * @property {string} stack\n */\n\n/** @typedef {{[key: string]: {[key: string]: {[key: string]: {[key: number]: {args: object, primary_key: number | string, id: number}}}}}} PoolDataType */\n/** @typedef {import(\"./base-model.js\").default & {id: () => number | string}} BaseModelWithId */\n\nconst shared = {}\n\n/** Batches command submissions and flushes them over HTTP or websockets. */\nexport default class ApiMakerCommandsPool {\n  /**\n   * Adds a command to the shared or one-off command pool and schedules a flush.\n   * @param {CommandDescriptor} data\n   * @param {CommandRequestOptions} [args]\n   * @returns {ApiMakerCommandExecution}\n   */\n  static addCommand(data, args = {}) {\n    let pool\n    const useWebsocketRequests = Config.getWebsocketRequests()\n\n    if (args.instant || useWebsocketRequests) {\n      pool = new ApiMakerCommandsPool()\n      pool.globalRequestData = {...ApiMakerCommandsPool.current().globalRequestData}\n      pool.requestOptions = {...args}\n    } else {\n      pool = ApiMakerCommandsPool.current()\n    }\n\n    const promiseResult = pool.addCommand(data)\n\n    if (args.instant || useWebsocketRequests) {\n      pool.flushRunLast.run()\n    } else {\n      pool.flushRunLast.queue()\n    }\n\n    return promiseResult\n  }\n\n  /**\n   * Returns the shared command pool instance.\n   * @returns {ApiMakerCommandsPool}\n   */\n  static current() {\n    if (!shared.currentApiMakerCommandsPool) shared.currentApiMakerCommandsPool = new ApiMakerCommandsPool()\n\n    return shared.currentApiMakerCommandsPool\n  }\n\n  /** Flushes the shared command pool immediately. */\n  static flush() {\n    ApiMakerCommandsPool.current().flush()\n  }\n\n  /** Initializes one command pool instance with empty queued state. */\n  constructor() {\n    this.flushCount = 0\n\n    /** @type {Record<number, CommandDataType>} */\n    this.pool = {}\n\n    /** @type {PoolDataType} */\n    this.poolData = {}\n\n    this.currentId = 1\n\n    /** @type {CommandArgumentMap} */\n    this.globalRequestData = {}\n\n    /** @type {CommandRequestOptions} */\n    this.requestOptions = {}\n  }\n\n  /**\n   * Adds one command execution to this pool instance.\n   * @param {CommandDescriptor} data\n   * @returns {ApiMakerCommandExecution}\n   */\n  addCommand(data) {\n    const stack = Error().stack\n    const id = this.currentId\n    const commandExecution = new ApiMakerCommandExecution()\n    const commandType = data.type\n    const commandName = data.command\n    const collectionName = data.collectionName\n\n    this.currentId += 1\n    this.pool[id] = {commandExecution, stack}\n\n    if (!this.poolData[commandType]) this.poolData[commandType] = {}\n    if (!this.poolData[commandType][collectionName]) this.poolData[commandType][collectionName] = {}\n    if (!this.poolData[commandType][collectionName][commandName]) this.poolData[commandType][collectionName][commandName] = {}\n\n    let args\n\n    if (data.args?.nodeName == \"FORM\") {\n      const formData = new FormData(data.args)\n\n      args = FormDataObjectizer.toObject(formData)\n    } else if (data.args instanceof FormData) {\n      args = FormDataObjectizer.toObject(data.args)\n    } else {\n      args = Serializer.serialize(data.args)\n    }\n\n    this.poolData[commandType][collectionName][commandName][id] = {\n      args,\n      primary_key: data.primaryKey,\n      id\n    }\n\n    return commandExecution\n  }\n\n  /** @returns {number} */\n  commandsCount() {\n    return Object.keys(this.pool).length\n  }\n\n  /**\n   * @param {object} args\n   * @param {string} args.url\n   * @param {CommandSubmitData} args.commandSubmitData\n   * @param {ApiMakerCommandExecution} [args.commandExecution]\n   * @returns {Promise<CommandsRequestResponse>}\n   */\n  async sendRequest({commandExecution, commandSubmitData, url}) {\n    for (let attempt = 0; attempt < 3; attempt++) {\n      const response = await this.performRequest({commandExecution, commandSubmitData, url}) // eslint-disable-line no-await-in-loop\n\n      if (response?.success === false && response.type == \"invalid_authenticity_token\") {\n        console.log(\"Invalid authenticity token - try again\")\n        await SessionStatusUpdater.current().updateSessionStatus() // eslint-disable-line no-await-in-loop\n        continue // eslint-disable-line no-continue\n      }\n\n      if (response?.success === false && response.type == \"authentication_changed\") {\n        const recovered = await this.recoverAuthentication() // eslint-disable-line no-await-in-loop\n\n        if (recovered) continue // eslint-disable-line no-continue\n\n        throw new SessionExpiredError()\n      }\n\n      return /** @type {CommandsRequestResponse} */ (response)\n    }\n\n    throw new Error(\"Couldnt successfully execute request\")\n  }\n\n  /**\n   * Performs a single command request over websocket or HTTP.\n   * @param {object} args\n   * @param {string} args.url\n   * @param {CommandSubmitData} args.commandSubmitData\n   * @param {ApiMakerCommandExecution} [args.commandExecution]\n   * @returns {Promise<CommandsRequestResponse>}\n   */\n  async performRequest({commandExecution, commandSubmitData, url}) {\n    if (Config.getWebsocketRequests() && !this.requestOptions.forceHttp && commandSubmitData.getFilesCount() == 0) {\n      return /** @type {Promise<CommandsRequestResponse>} */ (WebsocketRequestClient.current().perform({\n        cacheResponse: this.requestOptions.cacheResponse,\n        global: this.globalDataForRequest(),\n        onLog: (message) => commandExecution?.addLog(message),\n        onProgress: (progressData) => commandExecution?.setProgress(progressData),\n        onReceived: (receivedData) => commandExecution?.setReceived(receivedData),\n        request: commandSubmitData.getJsonData()\n      }))\n    }\n\n    if (commandSubmitData.getFilesCount() > 0) {\n      return /** @type {CommandsRequestResponse} */ (await Api.requestLocal({path: url, method: \"POST\", rawData: commandSubmitData.getFormData()}))\n    }\n\n    return /** @type {CommandsRequestResponse} */ (await Api.requestLocal({path: url, method: \"POST\", data: commandSubmitData.getJsonData()}))\n  }\n\n  /**\n   * The user ids the frontend believes it is signed in as, keyed by Devise\n   * scope. Sent with each request so the backend can detect (and let the\n   * frontend recover from) a stale session before running commands. Undefined\n   * when nothing is signed in, so genuinely anonymous requests send no belief.\n   * @returns {Record<string, number | string> | undefined}\n   */\n  believedDeviseUserIds() {\n    const believed = /** @type {Record<string, number | string>} */ ({})\n\n    for (const scope of Devise.registeredScopes()) {\n      const model = Devise.current().getCurrentScope(scope)\n\n      if (model) believed[scope] = /** @type {BaseModelWithId} */ (model).id()\n    }\n\n    return Object.keys(believed).length > 0 ? believed : undefined\n  }\n\n  /**\n   * The global request data merged with the believed signed-in identity.\n   * @returns {Record<string, unknown>}\n   */\n  globalDataForRequest() {\n    const believed = this.believedDeviseUserIds()\n\n    if (!believed) return this.globalRequestData\n\n    return {...this.globalRequestData, believed_devise_user_ids: believed}\n  }\n\n  /**\n   * Recovers from an `authentication_changed` response: refreshes the existing\n   * websocket connection's auth in-place from the current server session (no\n   * reconnect, no password) and reconciles the local session cache. Returns\n   * whether a previously signed-in scope is still authenticated, so the request\n   * can be retried; false means the user is genuinely signed out (the sign-in\n   * form is shown centrally via the Devise sign-out event).\n   * @returns {Promise<boolean>}\n   */\n  async recoverAuthentication() {\n    const sessionStatusUpdater = SessionStatusUpdater.current()\n    const sessionStatus = await sessionStatusUpdater.sessionStatus()\n    const scopes = Devise.registeredScopes()\n\n    await Promise.all(\n      scopes.map((scope) => Devise.refreshWebsocketSession({scope, shadowSessionToken: sessionStatus?.shadow_session_token}))\n    )\n\n    sessionStatusUpdater.applyResult(sessionStatus)\n\n    return scopes.some((scope) => Boolean(sessionStatus?.scopes?.[scope]?.signed_in))\n  }\n\n  /** Sends the currently queued commands and resolves or rejects their executions. */\n  flush = async () => {\n    if (this.commandsCount() == 0) {\n      return\n    }\n\n    const currentPool = this.pool\n    const currentPoolData = this.poolData\n\n    this.pool = {}\n    this.poolData = {}\n    this.flushCount++\n\n    try {\n      const submitData = {pool: currentPoolData}\n      const globalData = this.globalDataForRequest()\n\n      if (Object.keys(globalData).length > 0)\n        submitData.global = globalData\n\n      const commandSubmitData = new CommandSubmitData(submitData)\n      const url = \"/api_maker/commands\"\n      const commandExecution = Object.values(currentPool)[0]?.commandExecution\n      const response = await this.sendRequest({commandExecution, commandSubmitData, url})\n\n      await Promise.all(Object.keys(response.responses).map(async(commandId) => {\n        const commandResponse = response.responses[commandId]\n        const commandResponseData = Deserializer.parse(commandResponse.data)\n        const commandData = currentPool[parseInt(commandId, 10)]\n        const responseType = commandResponse.type\n\n        if (commandResponseData && typeof commandResponseData == \"object\") {\n          const bugReportUrl = dig(commandResponseData, \"bug_report_url\")\n\n          if (bugReportUrl) {\n            console.log(`Bug report URL: ${bugReportUrl}`)\n          }\n        }\n\n        if (responseType == \"success\") {\n          commandData.commandExecution.resolve(commandResponseData)\n        } else if (responseType == \"error\") {\n          this.rejectWithCallerStack(commandData, new CustomError(\"Command error\", {response: commandResponseData}))\n        } else if (responseType == \"failed\") {\n          await this.handleFailedResponse(commandData, commandResponseData)\n        } else {\n          throw new Error(`Unhandled response type: ${responseType}`)\n        }\n      }))\n    } catch (error) {\n      // sendRequest (e.g. an unrecoverable SessionExpiredError) or response\n      // handling can throw before the per-command promises are settled. Reject\n      // every queued command so callers awaiting their execution don't hang\n      // forever. Already-settled executions ignore the extra reject.\n      for (const commandData of Object.values(currentPool)) {\n        commandData.commandExecution.reject(/** @type {Error} */ (error))\n      }\n    } finally {\n      this.flushCount--\n    }\n  }\n\n  /**\n   * @param {CommandDataType} commandData\n   * @param {FailedCommandResponseData} commandResponseData\n   * @returns {Promise<void>}\n   */\n  async handleFailedResponse(commandData, commandResponseData) {\n    await this.refreshSessionStatusForNoAccessError(commandResponseData)\n\n    let error\n\n    if (commandResponseData.error_type == \"destroy_error\") {\n      error = new DestroyError(\"Destroy failed\", {response: commandResponseData})\n    } else if (commandResponseData.error_type == \"validation_error\") {\n      const validationErrors = new ValidationErrors({\n        model: digg(commandResponseData, \"model\"),\n        validationErrors: digg(commandResponseData, \"validation_errors\")\n      })\n      error = new ValidationError(validationErrors, {response: commandResponseData})\n\n      events.emit(\"onValidationErrors\", validationErrors)\n    } else {\n      const errorMessage = commandResponseData.errors ? undefined : \"Command failed\"\n\n      error = new CustomError(errorMessage, {response: commandResponseData})\n    }\n\n    this.rejectWithCallerStack(commandData, error)\n  }\n\n  /**\n   * Rejects the command with the given error, splicing the caller's stack (captured synchronously in addCommand) onto error.stack.\n   * Needed because error.stack is frozen at construction time inside flush()'s microtask and therefore loses the caller's frames.\n   * @param {CommandDataType} commandData\n   * @param {Error} error\n   * @returns {void}\n   */\n  rejectWithCallerStack(commandData, error) {\n    if (commandData.stack) {\n      // V8 prefixes \"Error\\n\" as a header; JSC/SpiderMonkey stacks start directly with a frame.\n      const callerFrames = commandData.stack.startsWith(\"Error\")\n        ? commandData.stack\n          .split(\"\\n\")\n          .slice(1)\n          .join(\"\\n\")\n        : commandData.stack\n\n      if (callerFrames) {\n        error.stack = `${error.stack ?? \"\"}\\n${callerFrames}`\n      }\n    }\n\n    commandData.commandExecution.reject(error)\n  }\n\n  /**\n   * @param {FailedCommandResponseData} commandResponseData\n   * @returns {Promise<void>}\n   */\n  async refreshSessionStatusForNoAccessError(commandResponseData) {\n    if (commandResponseData.error_type != \"not_found_or_no_access\") {\n      return\n    }\n\n    const signedInScope = Devise\n      .registeredScopes()\n      .find((scope) => Devise.current().hasCurrentScope(scope) || Devise.current().hasGlobalCurrentScope(scope))\n\n    if (!signedInScope) {\n      return\n    }\n\n    await SessionStatusUpdater.current().updateSessionStatus()\n  }\n\n  /**\n   * Returns true while one or more flushes are still in progress.\n   * @returns {boolean}\n   */\n  isActive() {\n    if (this.commandsCount() > 0) {\n      return true\n    }\n\n    if (this.flushCount > 0) {\n      return true\n    }\n\n    return false\n  }\n\n  flushRunLast = new RunLast(this.flush)\n}\n"]}

package/build/config.d.ts

@@ -62,5 +62,26 @@ declare class ApiMakerConfig {
      * @param {boolean} _newValue
      */
     setUseHtmlForm(_newValue: boolean): void;
+    /**
+     * Opens a streaming file sink for table exports on platforms without a web default (e.g. React
+     * Native/Expo). Receives `{fileName, mimeType, format}` and returns a sink
+     * `{write(chunk), close(), abort()}`.
+     * @returns {((args: object) => Promise<object>) | undefined}
+     */
+    getExportFileSinkOpener(): ((args: object) => Promise<object>) | undefined;
+    /**
+     * @param {((args: object) => Promise<object>) | undefined} opener
+     */
+    setExportFileSinkOpener(opener: ((args: object) => Promise<object>) | undefined): void;
+    /**
+     * Serializes an array-of-arrays (header + rows) into xlsx bytes, enabling the optional Excel export format
+     * without api_maker depending on a spreadsheet library. Returns a `Uint8Array` (or a promise of one).
+     * @returns {((rows: Array<Array<unknown>>) => Uint8Array | Promise<Uint8Array>) | undefined}
+     */
+    getExportXlsxSerializer(): ((rows: Array<Array<unknown>>) => Uint8Array | Promise<Uint8Array>) | undefined;
+    /**
+     * @param {((rows: Array<Array<unknown>>) => Uint8Array | Promise<Uint8Array>) | undefined} serializer
+     */
+    setExportXlsxSerializer(serializer: ((rows: Array<Array<unknown>>) => Uint8Array | Promise<Uint8Array>) | undefined): void;
 }
 //# sourceMappingURL=config.d.ts.map

package/build/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"/src/","sources":["config.js"],"names":[],"mappings":";mCAIc,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC;6BAChC,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC;uBAC7B,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;+BACtB;IAAC,MAAM,EAAE,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC,CAAA;CAAC;2BAE9C;IAAC,IAAI,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE;QAAC,QAAQ,EAAE,WAAW,CAAC;QAAC,QAAQ,EAAE,WAAW,CAAA;KAAC,KAAK,IAAI,CAAA;CAAC;0BAG5F,oBAAoB,EAAE,GAAG,cAAc,EAAE,GAAG,QAAQ,GAAG,gBAAgB,GAAG,YAAY,GAClG,OAAW,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS;AAyJnD,6CAA2C;6BArKhB,eAAe;AAkD1C,uFAAuF;AACvF;IAKI,YAA6C;IAC7C,2CAAgC;IAGlC;;;OAGG;IACH,aAFa,YAAY,CAES;IAElC,kDAAkD;IAClD,cADc,OAAO,SAAS,EAAE,cAAc,CAG7C;IAED,wBAAwB;IACxB,WADc,MAAM,CAGnB;IAED,oCAAoC;IACpC,eADc,MAAM,GAAG,SAAS,CAG/B;IAED,wBAAwB;IACxB,iCADc,MAAM,CAGnB;IAED;;OAEG;IACH,yCAFW,MAAM,QAEyF;IAE1G;;OAEG;IACH,uBAFW,MAAM,GAAG,SAAS,QAEyC;IAEtE,qCAAqC;IACrC,wBADc,OAAO,GAAG,SAAS,CAGhC;IAED;;OAEG;IACH,gCAFW,OAAO,GAAG,SAAS,QAE0D;IAExF,uCAAuC;IACvC,2BADc,KAAK,CAAC,cAAc,CAAC,CAGlC;IAED,wBAAwB;IACxB,YADc,MAAM,CAGnB;IAED,kCAAkC;IAClC,uBADc,gBAAgB,CAG7B;IAED,0BAA0B;IAC1B,aADc,QAAQ,CAGrB;IAED,yBAAyB;IACzB,kBADc,OAAO,CAGpB;IAED;;OAEG;IACH,0BAFW,OAAO,QAE0D;CAC7E"}
+{"version":3,"file":"config.d.ts","sourceRoot":"/src/","sources":["config.js"],"names":[],"mappings":";mCAIc,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC;6BAChC,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC;uBAC7B,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;+BACtB;IAAC,MAAM,EAAE,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC,CAAA;CAAC;2BAE9C;IAAC,IAAI,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE;QAAC,QAAQ,EAAE,WAAW,CAAC;QAAC,QAAQ,EAAE,WAAW,CAAA;KAAC,KAAK,IAAI,CAAA;CAAC;0BAG5F,oBAAoB,EAAE,GAAG,cAAc,EAAE,GAAG,QAAQ,GAAG,gBAAgB,GAAG,YAAY,GAClG,OAAW,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS;AAqLnD,6CAA2C;6BAjMhB,eAAe;AAkD1C,uFAAuF;AACvF;IAKI,YAA6C;IAC7C,2CAAgC;IAGlC;;;OAGG;IACH,aAFa,YAAY,CAES;IAElC,kDAAkD;IAClD,cADc,OAAO,SAAS,EAAE,cAAc,CAG7C;IAED,wBAAwB;IACxB,WADc,MAAM,CAGnB;IAED,oCAAoC;IACpC,eADc,MAAM,GAAG,SAAS,CAG/B;IAED,wBAAwB;IACxB,iCADc,MAAM,CAGnB;IAED;;OAEG;IACH,yCAFW,MAAM,QAEyF;IAE1G;;OAEG;IACH,uBAFW,MAAM,GAAG,SAAS,QAEyC;IAEtE,qCAAqC;IACrC,wBADc,OAAO,GAAG,SAAS,CAGhC;IAED;;OAEG;IACH,gCAFW,OAAO,GAAG,SAAS,QAE0D;IAExF,uCAAuC;IACvC,2BADc,KAAK,CAAC,cAAc,CAAC,CAGlC;IAED,wBAAwB;IACxB,YADc,MAAM,CAGnB;IAED,kCAAkC;IAClC,uBADc,gBAAgB,CAG7B;IAED,0BAA0B;IAC1B,aADc,QAAQ,CAGrB;IAED,yBAAyB;IACzB,kBADc,OAAO,CAGpB;IAED;;OAEG;IACH,0BAFW,OAAO,QAE0D;IAK5E;;;;;OAKG;IACH,2BAFa,CAAC,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,SAAS,CAES;IAErE;;OAEG;IACH,gCAFW,CAAC,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,SAAS,QAEmB;IAE7E;;;;OAIG;IACH,2BAFa,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,KAAK,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,GAAG,SAAS,CAEvB;IAErE;;OAEG;IACH,oCAFW,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,KAAK,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,GAAG,SAAS,QAEL;CACtF"}

package/build/config.js

@@ -115,6 +115,29 @@ class ApiMakerConfig {
      * @param {boolean} _newValue
      */
     setUseHtmlForm(_newValue) { apiMakerConfigNotImplemented("setUseHtmlForm"); }
+    // Table export hooks. These hold functions that should be returned as-is (not invoked), so they use
+    // explicit accessors instead of the generic accessor loop below (which would call function values).
+    /**
+     * Opens a streaming file sink for table exports on platforms without a web default (e.g. React
+     * Native/Expo). Receives `{fileName, mimeType, format}` and returns a sink
+     * `{write(chunk), close(), abort()}`.
+     * @returns {((args: object) => Promise<object>) | undefined}
+     */
+    getExportFileSinkOpener() { return this.global.exportFileSinkOpener; }
+    /**
+     * @param {((args: object) => Promise<object>) | undefined} opener
+     */
+    setExportFileSinkOpener(opener) { this.global.exportFileSinkOpener = opener; }
+    /**
+     * Serializes an array-of-arrays (header + rows) into xlsx bytes, enabling the optional Excel export format
+     * without api_maker depending on a spreadsheet library. Returns a `Uint8Array` (or a promise of one).
+     * @returns {((rows: Array<Array<unknown>>) => Uint8Array | Promise<Uint8Array>) | undefined}
+     */
+    getExportXlsxSerializer() { return this.global.exportXlsxSerializer; }
+    /**
+     * @param {((rows: Array<Array<unknown>>) => Uint8Array | Promise<Uint8Array>) | undefined} serializer
+     */
+    setExportXlsxSerializer(serializer) { this.global.exportXlsxSerializer = serializer; }
 }
 for (const accessorName in accessors) {
     const accessorData = accessors[accessorName];
@@ -141,4 +164,4 @@ for (const accessorName in accessors) {
 }
 const apiMakerConfig = new ApiMakerConfig();
 export default apiMakerConfig;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config.js","sourceRoot":"/src/","sources":["config.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\nimport {EventEmitter} from \"eventemitter3\"\nimport * as inflection from \"inflection\" // eslint-disable-line sort-imports\n\n/** @typedef {[name: string, minWidth: number]} BreakpointDefinition */\n/** @typedef {[label: string, code: string]} CurrencyOption */\n/** @typedef {Record<string, object>} RouteMap */\n/** @typedef {{routes: Array<{name: string, path: string}>}} RouteDefinitions */\n/**\n * @typedef {{emit: (eventName: string, payload: {oldValue: ConfigValue, newValue: ConfigValue}) => void}} ConfigEvents\n */\n/**\n * @typedef {BreakpointDefinition[] | CurrencyOption[] | RouteMap | RouteDefinitions | EventEmitter |\n *   boolean | number | object | string | undefined} ConfigValue\n */\n\nconst accessors = {\n  breakpoints: {\n    default: [\n      [\"xxl\", 1400],\n      [\"xl\", 1200],\n      [\"lg\", 992],\n      [\"md\", 768],\n      [\"sm\", 576],\n      [\"xs\", 0]\n    ],\n    required: true\n  },\n  cableUrl: {require: false},\n  currenciesCollection: {required: true},\n  dangerousRowCountThreshold: {default: 1000, required: false},\n  history: {required: true},\n  host: {required: false},\n  i18n: {required: false},\n  linkTo: {required: true},\n  modal: {required: false},\n  navigation: {required: true},\n  routes: {required: false},\n  routeDefinitions: {required: false},\n  useHtmlForm: {default: false, required: false},\n  websocketRequests: {required: false}\n}\n\n/**\n * @param {string} methodName\n * @returns {never}\n */\nconst apiMakerConfigNotImplemented = (methodName) => {\n  throw new Error(`'${methodName}' not implemented`)\n}\n\n/** Stores globally configured Api Maker integration hooks and runtime dependencies. */\nclass ApiMakerConfig {\n  /** Initializes the shared config state and change emitter. */\n  constructor() {\n    if (!globalThis.apiMakerConfigGlobal) globalThis.apiMakerConfigGlobal = {}\n\n    this.global = globalThis.apiMakerConfigGlobal\n    this.events = new EventEmitter()\n  }\n\n  /**\n   * Returns the event emitter used for config change notifications.\n   * @returns {ConfigEvents}\n   */\n  getEvents() { return this.events }\n\n  /** @returns {import(\"history\").BrowserHistory} */\n  getHistory() {\n    return apiMakerConfigNotImplemented(\"getHistory\")\n  }\n\n  /** @returns {string} */\n  getHost() {\n    return apiMakerConfigNotImplemented(\"getHost\")\n  }\n\n  /** @returns {string | undefined} */\n  getCableUrl() {\n    return apiMakerConfigNotImplemented(\"getCableUrl\")\n  }\n\n  /** @returns {number} */\n  getDangerousRowCountThreshold() {\n    return apiMakerConfigNotImplemented(\"getDangerousRowCountThreshold\")\n  }\n\n  /**\n   * @param {number} _newValue\n   */\n  setDangerousRowCountThreshold(_newValue) { apiMakerConfigNotImplemented(\"setDangerousRowCountThreshold\") }\n\n  /**\n   * @param {string | undefined} _newValue\n   */\n  setCableUrl(_newValue) { apiMakerConfigNotImplemented(\"setCableUrl\") }\n\n  /** @returns {boolean | undefined} */\n  getWebsocketRequests() {\n    return apiMakerConfigNotImplemented(\"getWebsocketRequests\")\n  }\n\n  /**\n   * @param {boolean | undefined} _newValue\n   */\n  setWebsocketRequests(_newValue) { apiMakerConfigNotImplemented(\"setWebsocketRequests\") }\n\n  /** @returns {Array<CurrencyOption>} */\n  getCurrenciesCollection() {\n    return apiMakerConfigNotImplemented(\"getCurrenciesCollection\")\n  }\n\n  /** @returns {object} */\n  getModal() {\n    return apiMakerConfigNotImplemented(\"getModal\")\n  }\n\n  /** @returns {RouteDefinitions} */\n  getRouteDefinitions() {\n    return apiMakerConfigNotImplemented(\"getRouteDefinitions\")\n  }\n\n  /** @returns {RouteMap} */\n  getRoutes() {\n    return apiMakerConfigNotImplemented(\"getRoutes\")\n  }\n\n  /** @returns {boolean} */\n  getUseHtmlForm() {\n    return apiMakerConfigNotImplemented(\"getUseHtmlForm\")\n  }\n\n  /**\n   * @param {boolean} _newValue\n   */\n  setUseHtmlForm(_newValue) { apiMakerConfigNotImplemented(\"setUseHtmlForm\") }\n}\n\nfor (const accessorName in accessors) {\n  const accessorData = accessors[accessorName]\n  const camelizedAccessor = inflection.camelize(accessorName)\n\n  ApiMakerConfig.prototype[`set${camelizedAccessor}`] = function (newValue) {\n    const oldValue = this.global[accessorName]\n\n    this.global[accessorName] = newValue\n\n    if (oldValue !== newValue) {\n      this.events.emit(`on${camelizedAccessor}Change`, {oldValue, newValue})\n    }\n  }\n\n  ApiMakerConfig.prototype[`get${camelizedAccessor}`] = function (...args) {\n    if (this.global[accessorName] === undefined) {\n      if (accessorData.default !== undefined) return accessorData.default\n      if (accessorData.required) throw new Error(`${accessorName} hasn't been set`)\n    }\n\n    const value = this.global[accessorName]\n\n    if (typeof value == \"function\") return value(...args)\n\n    return value\n  }\n}\n\nconst apiMakerConfig = new ApiMakerConfig()\n\nexport default apiMakerConfig\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config.js","sourceRoot":"/src/","sources":["config.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\nimport {EventEmitter} from \"eventemitter3\"\nimport * as inflection from \"inflection\" // eslint-disable-line sort-imports\n\n/** @typedef {[name: string, minWidth: number]} BreakpointDefinition */\n/** @typedef {[label: string, code: string]} CurrencyOption */\n/** @typedef {Record<string, object>} RouteMap */\n/** @typedef {{routes: Array<{name: string, path: string}>}} RouteDefinitions */\n/**\n * @typedef {{emit: (eventName: string, payload: {oldValue: ConfigValue, newValue: ConfigValue}) => void}} ConfigEvents\n */\n/**\n * @typedef {BreakpointDefinition[] | CurrencyOption[] | RouteMap | RouteDefinitions | EventEmitter |\n *   boolean | number | object | string | undefined} ConfigValue\n */\n\nconst accessors = {\n  breakpoints: {\n    default: [\n      [\"xxl\", 1400],\n      [\"xl\", 1200],\n      [\"lg\", 992],\n      [\"md\", 768],\n      [\"sm\", 576],\n      [\"xs\", 0]\n    ],\n    required: true\n  },\n  cableUrl: {require: false},\n  currenciesCollection: {required: true},\n  dangerousRowCountThreshold: {default: 1000, required: false},\n  history: {required: true},\n  host: {required: false},\n  i18n: {required: false},\n  linkTo: {required: true},\n  modal: {required: false},\n  navigation: {required: true},\n  routes: {required: false},\n  routeDefinitions: {required: false},\n  useHtmlForm: {default: false, required: false},\n  websocketRequests: {required: false}\n}\n\n/**\n * @param {string} methodName\n * @returns {never}\n */\nconst apiMakerConfigNotImplemented = (methodName) => {\n  throw new Error(`'${methodName}' not implemented`)\n}\n\n/** Stores globally configured Api Maker integration hooks and runtime dependencies. */\nclass ApiMakerConfig {\n  /** Initializes the shared config state and change emitter. */\n  constructor() {\n    if (!globalThis.apiMakerConfigGlobal) globalThis.apiMakerConfigGlobal = {}\n\n    this.global = globalThis.apiMakerConfigGlobal\n    this.events = new EventEmitter()\n  }\n\n  /**\n   * Returns the event emitter used for config change notifications.\n   * @returns {ConfigEvents}\n   */\n  getEvents() { return this.events }\n\n  /** @returns {import(\"history\").BrowserHistory} */\n  getHistory() {\n    return apiMakerConfigNotImplemented(\"getHistory\")\n  }\n\n  /** @returns {string} */\n  getHost() {\n    return apiMakerConfigNotImplemented(\"getHost\")\n  }\n\n  /** @returns {string | undefined} */\n  getCableUrl() {\n    return apiMakerConfigNotImplemented(\"getCableUrl\")\n  }\n\n  /** @returns {number} */\n  getDangerousRowCountThreshold() {\n    return apiMakerConfigNotImplemented(\"getDangerousRowCountThreshold\")\n  }\n\n  /**\n   * @param {number} _newValue\n   */\n  setDangerousRowCountThreshold(_newValue) { apiMakerConfigNotImplemented(\"setDangerousRowCountThreshold\") }\n\n  /**\n   * @param {string | undefined} _newValue\n   */\n  setCableUrl(_newValue) { apiMakerConfigNotImplemented(\"setCableUrl\") }\n\n  /** @returns {boolean | undefined} */\n  getWebsocketRequests() {\n    return apiMakerConfigNotImplemented(\"getWebsocketRequests\")\n  }\n\n  /**\n   * @param {boolean | undefined} _newValue\n   */\n  setWebsocketRequests(_newValue) { apiMakerConfigNotImplemented(\"setWebsocketRequests\") }\n\n  /** @returns {Array<CurrencyOption>} */\n  getCurrenciesCollection() {\n    return apiMakerConfigNotImplemented(\"getCurrenciesCollection\")\n  }\n\n  /** @returns {object} */\n  getModal() {\n    return apiMakerConfigNotImplemented(\"getModal\")\n  }\n\n  /** @returns {RouteDefinitions} */\n  getRouteDefinitions() {\n    return apiMakerConfigNotImplemented(\"getRouteDefinitions\")\n  }\n\n  /** @returns {RouteMap} */\n  getRoutes() {\n    return apiMakerConfigNotImplemented(\"getRoutes\")\n  }\n\n  /** @returns {boolean} */\n  getUseHtmlForm() {\n    return apiMakerConfigNotImplemented(\"getUseHtmlForm\")\n  }\n\n  /**\n   * @param {boolean} _newValue\n   */\n  setUseHtmlForm(_newValue) { apiMakerConfigNotImplemented(\"setUseHtmlForm\") }\n\n  // Table export hooks. These hold functions that should be returned as-is (not invoked), so they use\n  // explicit accessors instead of the generic accessor loop below (which would call function values).\n\n  /**\n   * Opens a streaming file sink for table exports on platforms without a web default (e.g. React\n   * Native/Expo). Receives `{fileName, mimeType, format}` and returns a sink\n   * `{write(chunk), close(), abort()}`.\n   * @returns {((args: object) => Promise<object>) | undefined}\n   */\n  getExportFileSinkOpener() { return this.global.exportFileSinkOpener }\n\n  /**\n   * @param {((args: object) => Promise<object>) | undefined} opener\n   */\n  setExportFileSinkOpener(opener) { this.global.exportFileSinkOpener = opener }\n\n  /**\n   * Serializes an array-of-arrays (header + rows) into xlsx bytes, enabling the optional Excel export format\n   * without api_maker depending on a spreadsheet library. Returns a `Uint8Array` (or a promise of one).\n   * @returns {((rows: Array<Array<unknown>>) => Uint8Array | Promise<Uint8Array>) | undefined}\n   */\n  getExportXlsxSerializer() { return this.global.exportXlsxSerializer }\n\n  /**\n   * @param {((rows: Array<Array<unknown>>) => Uint8Array | Promise<Uint8Array>) | undefined} serializer\n   */\n  setExportXlsxSerializer(serializer) { this.global.exportXlsxSerializer = serializer }\n}\n\nfor (const accessorName in accessors) {\n  const accessorData = accessors[accessorName]\n  const camelizedAccessor = inflection.camelize(accessorName)\n\n  ApiMakerConfig.prototype[`set${camelizedAccessor}`] = function (newValue) {\n    const oldValue = this.global[accessorName]\n\n    this.global[accessorName] = newValue\n\n    if (oldValue !== newValue) {\n      this.events.emit(`on${camelizedAccessor}Change`, {oldValue, newValue})\n    }\n  }\n\n  ApiMakerConfig.prototype[`get${camelizedAccessor}`] = function (...args) {\n    if (this.global[accessorName] === undefined) {\n      if (accessorData.default !== undefined) return accessorData.default\n      if (accessorData.required) throw new Error(`${accessorName} hasn't been set`)\n    }\n\n    const value = this.global[accessorName]\n\n    if (typeof value == \"function\") return value(...args)\n\n    return value\n  }\n}\n\nconst apiMakerConfig = new ApiMakerConfig()\n\nexport default apiMakerConfig\n"]}

package/build/session-expired-error.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Raised by the commands pool when a request could not run because the session
+ * had expired (the frontend's believed user diverged from the backend's actual
+ * user) and could not be renewed. Callers can treat this as a benign "please
+ * sign in again" signal — the sign-in form is shown centrally via the Devise
+ * sign-out event — rather than a real command failure.
+ */
+export default class ApiMakerSessionExpiredError extends Error {
+    static apiMakerType: string;
+    /** @param {string} [message] */
+    constructor(message?: string);
+    apiMakerType: string;
+}
+//# sourceMappingURL=session-expired-error.d.ts.map

package/build/session-expired-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-expired-error.d.ts","sourceRoot":"/src/","sources":["session-expired-error.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH;IACE,4BAA2C;IAG3C,gCAAgC;IAChC,sBADY,MAAM,EAKjB;IAPD,qBAAoC;CAQrC"}