@kaspernj/api-maker 1.0.2172 → 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/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"}

package/build/session-expired-error.js

@@ -0,0 +1,19 @@
+// @ts-check
+/**
+ * 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 = "SessionExpiredError";
+    apiMakerType = "SessionExpiredError";
+    /** @param {string} [message] */
+    constructor(message = "The session has expired") {
+        super(message);
+        if (Error.captureStackTrace)
+            Error.captureStackTrace(this, ApiMakerSessionExpiredError);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2Vzc2lvbi1leHBpcmVkLWVycm9yLmpzIiwic291cmNlUm9vdCI6Ii9zcmMvIiwic291cmNlcyI6WyJzZXNzaW9uLWV4cGlyZWQtZXJyb3IuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsWUFBWTtBQUVaOzs7Ozs7R0FNRztBQUNILE1BQU0sQ0FBQyxPQUFPLE9BQU8sMkJBQTRCLFNBQVEsS0FBSztJQUM1RCxNQUFNLENBQUMsWUFBWSxHQUFHLHFCQUFxQixDQUFBO0lBQzNDLFlBQVksR0FBRyxxQkFBcUIsQ0FBQTtJQUVwQyxnQ0FBZ0M7SUFDaEMsWUFBWSxPQUFPLEdBQUcseUJBQXlCO1FBQzdDLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQTtRQUVkLElBQUksS0FBSyxDQUFDLGlCQUFpQjtZQUFFLEtBQUssQ0FBQyxpQkFBaUIsQ0FBQyxJQUFJLEVBQUUsMkJBQTJCLENBQUMsQ0FBQTtJQUN6RixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQHRzLWNoZWNrXG5cbi8qKlxuICogUmFpc2VkIGJ5IHRoZSBjb21tYW5kcyBwb29sIHdoZW4gYSByZXF1ZXN0IGNvdWxkIG5vdCBydW4gYmVjYXVzZSB0aGUgc2Vzc2lvblxuICogaGFkIGV4cGlyZWQgKHRoZSBmcm9udGVuZCdzIGJlbGlldmVkIHVzZXIgZGl2ZXJnZWQgZnJvbSB0aGUgYmFja2VuZCdzIGFjdHVhbFxuICogdXNlcikgYW5kIGNvdWxkIG5vdCBiZSByZW5ld2VkLiBDYWxsZXJzIGNhbiB0cmVhdCB0aGlzIGFzIGEgYmVuaWduIFwicGxlYXNlXG4gKiBzaWduIGluIGFnYWluXCIgc2lnbmFsIOKAlCB0aGUgc2lnbi1pbiBmb3JtIGlzIHNob3duIGNlbnRyYWxseSB2aWEgdGhlIERldmlzZVxuICogc2lnbi1vdXQgZXZlbnQg4oCUIHJhdGhlciB0aGFuIGEgcmVhbCBjb21tYW5kIGZhaWx1cmUuXG4gKi9cbmV4cG9ydCBkZWZhdWx0IGNsYXNzIEFwaU1ha2VyU2Vzc2lvbkV4cGlyZWRFcnJvciBleHRlbmRzIEVycm9yIHtcbiAgc3RhdGljIGFwaU1ha2VyVHlwZSA9IFwiU2Vzc2lvbkV4cGlyZWRFcnJvclwiXG4gIGFwaU1ha2VyVHlwZSA9IFwiU2Vzc2lvbkV4cGlyZWRFcnJvclwiXG5cbiAgLyoqIEBwYXJhbSB7c3RyaW5nfSBbbWVzc2FnZV0gKi9cbiAgY29uc3RydWN0b3IobWVzc2FnZSA9IFwiVGhlIHNlc3Npb24gaGFzIGV4cGlyZWRcIikge1xuICAgIHN1cGVyKG1lc3NhZ2UpXG5cbiAgICBpZiAoRXJyb3IuY2FwdHVyZVN0YWNrVHJhY2UpIEVycm9yLmNhcHR1cmVTdGFja1RyYWNlKHRoaXMsIEFwaU1ha2VyU2Vzc2lvbkV4cGlyZWRFcnJvcilcbiAgfVxufVxuIl19

package/build/session-status-updater.d.ts

@@ -6,6 +6,7 @@
  * @typedef {object} SessionStatusResult
  * @property {string} [csrf_token]
  * @property {Record<string, SessionStatusScope>} scopes
+ * @property {string} [shadow_session_token]
  */
 /**
  * @typedef {object} SessionStatusUpdaterArgs
@@ -32,6 +33,20 @@ export default class ApiMakerSessionStatusUpdater {
     connectOnlineEvent(): void;
     /** Re-checks session state when the device wakes from sleep. */
     connectWakeEvent(): void;
+    /**
+     * Re-checks session state when the user returns to a backgrounded tab/app.
+     * The `wake-event` package only fires on multi-second device-sleep drift, so
+     * it misses iOS Safari tab suspension; visibilitychange/focus/pageshow cover
+     * that, surfacing an expired session the moment the user returns.
+     */
+    connectVisibilityEvents(): void;
+    /**
+     * Schedules a debounced session-status refresh when the page becomes visible
+     * again. visibilitychange, focus and pageshow can fire together on return, so
+     * the refresh is collapsed into a single request.
+     */
+    refreshOnReturnToForeground: () => void;
+    returnRefreshTimeout: any;
     getCsrfToken(): Promise<string>;
     csrfToken: string;
     /**
@@ -79,6 +94,7 @@ export type SessionStatusScope = {
 export type SessionStatusResult = {
     csrf_token?: string;
     scopes: Record<string, SessionStatusScope>;
+    shadow_session_token?: string;
 };
 export type SessionStatusUpdaterArgs = {
     timeout?: number;

package/build/session-status-updater.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session-status-updater.d.ts","sourceRoot":"/src/","sources":["session-status-updater.js"],"names":[],"mappings":"AAYA;;;GAGG;AAEH;;;;GAIG;AAEH;;;;GAIG;AAEH,+CAA+C;AAC/C;IACE;;;;OAIG;IACH,sBAHW,wBAAwB,GACtB,4BAA4B,CAQxC;IAED;;;OAGG;IACH,mBAFW,wBAAwB,EAmBlC;IAhBC,WAAgB;IAChB,gBAAqC;IAGnC,wBAAyC;IAc7C,kEAAkE;IAClE,2BAEC;IAED,gEAAgE;IAChE,yBAEC;IAED,gCA+BC;IAlBK,kBAAyD;IAoB/D;;;OAGG;IACH,iBAFa,OAAO,CAAC,mBAAmB,CAAC,CAmBxC;IAED;;;OAGG;IACH,sCAGC;IAED,6DAA6D;IAC7D,qBAaC;IAPC,8BAMC;IAGH,gEAAgE;IAChE,oBAGC;IAED,gEAAgE;IAChE,yCAMC;IAED;;;OAGG;IACH,oBAHW,mBAAmB,GACjB,IAAI,CAOhB;IAED;;;OAGG;IACH,qCAFW,mBAAmB,QAqB7B;IAED;;;OAGG;IACH,qCAFW,mBAAmB,QAM7B;IAED;;;;OAIG;IACH,4CAHW,MAAM,SACN,kBAAkB,QAkB5B;CACF;;eAnOa,OAAO;;;iBAKP,MAAM;YACN,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC;;;cAKlC,MAAM;qBACN,OAAO"}
+{"version":3,"file":"session-status-updater.d.ts","sourceRoot":"/src/","sources":["session-status-updater.js"],"names":[],"mappings":"AAYA;;;GAGG;AAEH;;;;;GAKG;AAEH;;;;GAIG;AAEH,+CAA+C;AAC/C;IACE;;;;OAIG;IACH,sBAHW,wBAAwB,GACtB,4BAA4B,CAQxC;IAED;;;OAGG;IACH,mBAFW,wBAAwB,EAuBlC;IApBC,WAAgB;IAChB,gBAAqC;IAGnC,wBAAyC;IAkB7C,kEAAkE;IAClE,2BAEC;IAED,gEAAgE;IAChE,yBAEC;IAED;;;;;OAKG;IACH,gCAOC;IAED;;;;OAIG;IACH,wCAWC;IAJC,0BAGM;IAGR,gCA+BC;IAlBK,kBAAyD;IAoB/D;;;OAGG;IACH,iBAFa,OAAO,CAAC,mBAAmB,CAAC,CAmBxC;IAED;;;OAGG;IACH,sCAGC;IAED,6DAA6D;IAC7D,qBAaC;IAPC,8BAMC;IAGH,gEAAgE;IAChE,oBAGC;IAED,gEAAgE;IAChE,yCAMC;IAED;;;OAGG;IACH,oBAHW,mBAAmB,GACjB,IAAI,CAOhB;IAED;;;OAGG;IACH,qCAFW,mBAAmB,QAqB7B;IAED;;;OAGG;IACH,qCAFW,mBAAmB,QAM7B;IAED;;;;OAIG;IACH,4CAHW,MAAM,SACN,kBAAkB,QAkB5B;CACF;;eAzQa,OAAO;;;iBAKP,MAAM;YACN,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC;2BAClC,MAAM;;;cAKN,MAAM;qBACN,OAAO"}

package/build/session-status-updater.js

@@ -15,6 +15,7 @@ const shared = {};
  * @typedef {object} SessionStatusResult
  * @property {string} [csrf_token]
  * @property {Record<string, SessionStatusScope>} scopes
+ * @property {string} [shadow_session_token]
  */
 /**
  * @typedef {object} SessionStatusUpdaterArgs
@@ -53,6 +54,9 @@ export default class ApiMakerSessionStatusUpdater {
         if (typeof window != "undefined") {
             this.connectOnlineEvent();
         }
+        if (typeof document != "undefined") {
+            this.connectVisibilityEvents();
+        }
         this.connectWakeEvent();
     }
     /** Re-checks session state when the browser comes back online. */
@@ -63,6 +67,35 @@ export default class ApiMakerSessionStatusUpdater {
     connectWakeEvent() {
         wakeEvent(this.updateSessionStatus);
     }
+    /**
+     * Re-checks session state when the user returns to a backgrounded tab/app.
+     * The `wake-event` package only fires on multi-second device-sleep drift, so
+     * it misses iOS Safari tab suspension; visibilitychange/focus/pageshow cover
+     * that, surfacing an expired session the moment the user returns.
+     */
+    connectVisibilityEvents() {
+        document.addEventListener("visibilitychange", this.refreshOnReturnToForeground, false);
+        if (typeof window != "undefined") {
+            window.addEventListener("focus", this.refreshOnReturnToForeground, false);
+            window.addEventListener("pageshow", this.refreshOnReturnToForeground, false);
+        }
+    }
+    /**
+     * Schedules a debounced session-status refresh when the page becomes visible
+     * again. visibilitychange, focus and pageshow can fire together on return, so
+     * the refresh is collapsed into a single request.
+     */
+    refreshOnReturnToForeground = () => {
+        if (typeof document != "undefined" && document.visibilityState && document.visibilityState != "visible") {
+            return;
+        }
+        if (this.returnRefreshTimeout)
+            return;
+        this.returnRefreshTimeout = setTimeout(() => {
+            this.returnRefreshTimeout = undefined;
+            this.updateSessionStatus();
+        }, 50);
+    };
     async getCsrfToken() {
         if (this.csrfToken) {
             logger.debug(`Get CSRF token from set variable: ${this.csrfToken}`);
@@ -192,4 +225,4 @@ export default class ApiMakerSessionStatusUpdater {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"session-status-updater.js","sourceRoot":"/src/","sources":["session-status-updater.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\nimport * as inflection from \"inflection\"\nimport Devise from \"./devise.js\"\nimport Logger from \"./logger.js\"\nimport config from \"./config.js\"\nimport wakeEvent from \"wake-event\"\n\nconst logger = new Logger({name: \"ApiMaker / SessionStatusUpdater\"})\nconst shared = {}\n\n// logger.setDebug(true)\n\n/**\n * @typedef {object} SessionStatusScope\n * @property {boolean} signed_in\n */\n\n/**\n * @typedef {object} SessionStatusResult\n * @property {string} [csrf_token]\n * @property {Record<string, SessionStatusScope>} scopes\n */\n\n/**\n * @typedef {object} SessionStatusUpdaterArgs\n * @property {number} [timeout]\n * @property {boolean} [useMetaElement]\n */\n\n/** Tracks session and CSRF token freshness. */\nexport default class ApiMakerSessionStatusUpdater {\n  /**\n   * Returns the shared session-status updater instance.\n   * @param {SessionStatusUpdaterArgs} [args]\n   * @returns {ApiMakerSessionStatusUpdater}\n   */\n  static current(args) {\n    if (!shared.apiMakerSessionStatusUpdater) {\n      shared.apiMakerSessionStatusUpdater = new ApiMakerSessionStatusUpdater(args)\n    }\n\n    return shared.apiMakerSessionStatusUpdater\n  }\n\n  /**\n   * Sets up session-status polling and browser wake/online listeners.\n   * @param {SessionStatusUpdaterArgs} [args]\n   */\n  constructor(args = {}) {\n    this.events = {}\n    this.timeout = args.timeout || 600000\n\n    if (\"useMetaElement\" in args) {\n      this.useMetaElement = args.useMetaElement\n    } else if (typeof document === \"undefined\") {\n      this.useMetaElement = false\n    } else {\n      this.useMetaElement = true\n    }\n\n    if (typeof window != \"undefined\") {\n      this.connectOnlineEvent()\n    }\n\n    this.connectWakeEvent()\n  }\n\n  /** Re-checks session state when the browser comes back online. */\n  connectOnlineEvent() {\n    window.addEventListener(\"online\", this.updateSessionStatus, false)\n  }\n\n  /** Re-checks session state when the device wakes from sleep. */\n  connectWakeEvent() {\n    wakeEvent(this.updateSessionStatus)\n  }\n\n  async getCsrfToken() {\n    if (this.csrfToken) {\n      logger.debug(`Get CSRF token from set variable: ${this.csrfToken}`)\n\n      return this.csrfToken\n    }\n\n    if (this.useMetaElement) {\n      const csrfTokenElement = document.querySelector(\"meta[name='csrf-token']\")\n\n      if (csrfTokenElement) {\n        logger.debug(() => `Get CSRF token from meta element: ${csrfTokenElement.getAttribute(\"content\")}`)\n\n        this.csrfToken = csrfTokenElement.getAttribute(\"content\")\n\n        return this.csrfToken\n      }\n    }\n\n    logger.debug(\"Updating session status because no CSRF token set yet\")\n    await this.updateSessionStatus()\n\n    if (this.csrfToken) {\n      logger.debug(() => `Returning CSRF token after updating session status: ${this.csrfToken}`)\n\n      return this.csrfToken\n    }\n\n    logger.debug(\"No CSRF token available after updating session status\")\n\n    return undefined\n  }\n\n  /**\n   * Requests the latest backend session-status payload.\n   * @returns {Promise<SessionStatusResult>}\n   */\n  sessionStatus() {\n    return new Promise((resolve) => {\n      const host = config.getHost()\n      let requestPath = \"\"\n\n      if (host) requestPath += host\n\n      requestPath += \"/api_maker/session_statuses\"\n\n      const xhr = new XMLHttpRequest()\n      xhr.open(\"POST\", requestPath, true)\n      xhr.onload = () => {\n        const response = JSON.parse(xhr.responseText)\n        resolve(response)\n      }\n      xhr.send()\n    })\n  }\n\n  /**\n   * Registers a callback for frontend sign-out detection.\n   * @param {Function} callback\n   */\n  onSignedOut(callback) {\n    // @ts-expect-error\n    this.addEvent(\"onSignedOut\", callback)\n  }\n\n  /** Starts or refreshes the periodic session-status timer. */\n  startTimeout() {\n    logger.debug(\"startTimeout\")\n\n    if (this.updateTimeout)\n      clearTimeout(this.updateTimeout)\n\n    this.updateTimeout = setTimeout(\n      () => {\n        this.startTimeout()\n        this.updateSessionStatus()\n      },\n      this.timeout\n    )\n  }\n\n  /** Stops the periodic session-status timer if it is running. */\n  stopTimeout() {\n    if (this.updateTimeout)\n      clearTimeout(this.updateTimeout)\n  }\n\n  /** Fetches the latest session status and applies it locally. */\n  updateSessionStatus = async () => {\n    logger.debug(\"updateSessionStatus\")\n\n    const result = await this.sessionStatus()\n\n    this.applyResult(result)\n  }\n\n  /**\n   * @param {SessionStatusResult} result\n   * @returns {void}\n   */\n  applyResult(result) {\n    logger.debug(() => `Result: ${JSON.stringify(result, null, 2)}`)\n\n    this.updateMetaElementsFromResult(result)\n    this.updateUserSessionsFromResult(result)\n  }\n\n  /**\n   * Updates the cached and DOM CSRF token from one session-status response.\n   * @param {SessionStatusResult} result\n   */\n  updateMetaElementsFromResult(result) {\n    logger.debug(\"updateMetaElementsFromResult\")\n\n    if (!result.csrf_token) {\n      return\n    }\n\n    this.csrfToken = result.csrf_token\n\n    if (this.useMetaElement) {\n      const csrfTokenElement = document.querySelector(\"meta[name='csrf-token']\")\n\n      if (csrfTokenElement) {\n        logger.debug(() => `Changing token from \"${csrfTokenElement.getAttribute(\"content\")}\" to \"${result.csrf_token}\"`)\n        csrfTokenElement.setAttribute(\"content\", result.csrf_token)\n      } else {\n        logger.debug(\"csrf token element couldn't be found\")\n      }\n    }\n  }\n\n  /**\n   * Applies each returned scope status to the frontend Devise cache.\n   * @param {SessionStatusResult} result\n   */\n  updateUserSessionsFromResult(result) {\n    for (const scopeName in result.scopes) {\n      this.updateUserSessionScopeFromResult(scopeName, result.scopes[scopeName])\n    }\n  }\n\n  /**\n   * Applies one scope's signed-in state to the frontend Devise cache.\n   * @param {string} scopeName\n   * @param {SessionStatusScope} scope\n   */\n  updateUserSessionScopeFromResult(scopeName, scope) {\n    const deviseIsSignedInMethodName = `is${inflection.camelize(scopeName)}SignedIn`\n\n    if (!(deviseIsSignedInMethodName in Devise)) {\n      throw new Error(`No such method in Devise: ${deviseIsSignedInMethodName}`)\n    }\n\n    const currentlySignedIn = Devise[deviseIsSignedInMethodName]()\n    const signedInOnBackend = scope.signed_in\n\n    if (currentlySignedIn && !signedInOnBackend) {\n      logger.debug(() => `${inflection.camelize(scopeName)} signed in on frontend but not in backend!`)\n\n      Devise.setSignedOut({scope: scopeName})\n      Devise.callSignOutEvent({scope: scopeName})\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"session-status-updater.js","sourceRoot":"/src/","sources":["session-status-updater.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\nimport * as inflection from \"inflection\"\nimport Devise from \"./devise.js\"\nimport Logger from \"./logger.js\"\nimport config from \"./config.js\"\nimport wakeEvent from \"wake-event\"\n\nconst logger = new Logger({name: \"ApiMaker / SessionStatusUpdater\"})\nconst shared = {}\n\n// logger.setDebug(true)\n\n/**\n * @typedef {object} SessionStatusScope\n * @property {boolean} signed_in\n */\n\n/**\n * @typedef {object} SessionStatusResult\n * @property {string} [csrf_token]\n * @property {Record<string, SessionStatusScope>} scopes\n * @property {string} [shadow_session_token]\n */\n\n/**\n * @typedef {object} SessionStatusUpdaterArgs\n * @property {number} [timeout]\n * @property {boolean} [useMetaElement]\n */\n\n/** Tracks session and CSRF token freshness. */\nexport default class ApiMakerSessionStatusUpdater {\n  /**\n   * Returns the shared session-status updater instance.\n   * @param {SessionStatusUpdaterArgs} [args]\n   * @returns {ApiMakerSessionStatusUpdater}\n   */\n  static current(args) {\n    if (!shared.apiMakerSessionStatusUpdater) {\n      shared.apiMakerSessionStatusUpdater = new ApiMakerSessionStatusUpdater(args)\n    }\n\n    return shared.apiMakerSessionStatusUpdater\n  }\n\n  /**\n   * Sets up session-status polling and browser wake/online listeners.\n   * @param {SessionStatusUpdaterArgs} [args]\n   */\n  constructor(args = {}) {\n    this.events = {}\n    this.timeout = args.timeout || 600000\n\n    if (\"useMetaElement\" in args) {\n      this.useMetaElement = args.useMetaElement\n    } else if (typeof document === \"undefined\") {\n      this.useMetaElement = false\n    } else {\n      this.useMetaElement = true\n    }\n\n    if (typeof window != \"undefined\") {\n      this.connectOnlineEvent()\n    }\n\n    if (typeof document != \"undefined\") {\n      this.connectVisibilityEvents()\n    }\n\n    this.connectWakeEvent()\n  }\n\n  /** Re-checks session state when the browser comes back online. */\n  connectOnlineEvent() {\n    window.addEventListener(\"online\", this.updateSessionStatus, false)\n  }\n\n  /** Re-checks session state when the device wakes from sleep. */\n  connectWakeEvent() {\n    wakeEvent(this.updateSessionStatus)\n  }\n\n  /**\n   * Re-checks session state when the user returns to a backgrounded tab/app.\n   * The `wake-event` package only fires on multi-second device-sleep drift, so\n   * it misses iOS Safari tab suspension; visibilitychange/focus/pageshow cover\n   * that, surfacing an expired session the moment the user returns.\n   */\n  connectVisibilityEvents() {\n    document.addEventListener(\"visibilitychange\", this.refreshOnReturnToForeground, false)\n\n    if (typeof window != \"undefined\") {\n      window.addEventListener(\"focus\", this.refreshOnReturnToForeground, false)\n      window.addEventListener(\"pageshow\", this.refreshOnReturnToForeground, false)\n    }\n  }\n\n  /**\n   * Schedules a debounced session-status refresh when the page becomes visible\n   * again. visibilitychange, focus and pageshow can fire together on return, so\n   * the refresh is collapsed into a single request.\n   */\n  refreshOnReturnToForeground = () => {\n    if (typeof document != \"undefined\" && document.visibilityState && document.visibilityState != \"visible\") {\n      return\n    }\n\n    if (this.returnRefreshTimeout) return\n\n    this.returnRefreshTimeout = setTimeout(() => {\n      this.returnRefreshTimeout = undefined\n      this.updateSessionStatus()\n    }, 50)\n  }\n\n  async getCsrfToken() {\n    if (this.csrfToken) {\n      logger.debug(`Get CSRF token from set variable: ${this.csrfToken}`)\n\n      return this.csrfToken\n    }\n\n    if (this.useMetaElement) {\n      const csrfTokenElement = document.querySelector(\"meta[name='csrf-token']\")\n\n      if (csrfTokenElement) {\n        logger.debug(() => `Get CSRF token from meta element: ${csrfTokenElement.getAttribute(\"content\")}`)\n\n        this.csrfToken = csrfTokenElement.getAttribute(\"content\")\n\n        return this.csrfToken\n      }\n    }\n\n    logger.debug(\"Updating session status because no CSRF token set yet\")\n    await this.updateSessionStatus()\n\n    if (this.csrfToken) {\n      logger.debug(() => `Returning CSRF token after updating session status: ${this.csrfToken}`)\n\n      return this.csrfToken\n    }\n\n    logger.debug(\"No CSRF token available after updating session status\")\n\n    return undefined\n  }\n\n  /**\n   * Requests the latest backend session-status payload.\n   * @returns {Promise<SessionStatusResult>}\n   */\n  sessionStatus() {\n    return new Promise((resolve) => {\n      const host = config.getHost()\n      let requestPath = \"\"\n\n      if (host) requestPath += host\n\n      requestPath += \"/api_maker/session_statuses\"\n\n      const xhr = new XMLHttpRequest()\n      xhr.open(\"POST\", requestPath, true)\n      xhr.onload = () => {\n        const response = JSON.parse(xhr.responseText)\n        resolve(response)\n      }\n      xhr.send()\n    })\n  }\n\n  /**\n   * Registers a callback for frontend sign-out detection.\n   * @param {Function} callback\n   */\n  onSignedOut(callback) {\n    // @ts-expect-error\n    this.addEvent(\"onSignedOut\", callback)\n  }\n\n  /** Starts or refreshes the periodic session-status timer. */\n  startTimeout() {\n    logger.debug(\"startTimeout\")\n\n    if (this.updateTimeout)\n      clearTimeout(this.updateTimeout)\n\n    this.updateTimeout = setTimeout(\n      () => {\n        this.startTimeout()\n        this.updateSessionStatus()\n      },\n      this.timeout\n    )\n  }\n\n  /** Stops the periodic session-status timer if it is running. */\n  stopTimeout() {\n    if (this.updateTimeout)\n      clearTimeout(this.updateTimeout)\n  }\n\n  /** Fetches the latest session status and applies it locally. */\n  updateSessionStatus = async () => {\n    logger.debug(\"updateSessionStatus\")\n\n    const result = await this.sessionStatus()\n\n    this.applyResult(result)\n  }\n\n  /**\n   * @param {SessionStatusResult} result\n   * @returns {void}\n   */\n  applyResult(result) {\n    logger.debug(() => `Result: ${JSON.stringify(result, null, 2)}`)\n\n    this.updateMetaElementsFromResult(result)\n    this.updateUserSessionsFromResult(result)\n  }\n\n  /**\n   * Updates the cached and DOM CSRF token from one session-status response.\n   * @param {SessionStatusResult} result\n   */\n  updateMetaElementsFromResult(result) {\n    logger.debug(\"updateMetaElementsFromResult\")\n\n    if (!result.csrf_token) {\n      return\n    }\n\n    this.csrfToken = result.csrf_token\n\n    if (this.useMetaElement) {\n      const csrfTokenElement = document.querySelector(\"meta[name='csrf-token']\")\n\n      if (csrfTokenElement) {\n        logger.debug(() => `Changing token from \"${csrfTokenElement.getAttribute(\"content\")}\" to \"${result.csrf_token}\"`)\n        csrfTokenElement.setAttribute(\"content\", result.csrf_token)\n      } else {\n        logger.debug(\"csrf token element couldn't be found\")\n      }\n    }\n  }\n\n  /**\n   * Applies each returned scope status to the frontend Devise cache.\n   * @param {SessionStatusResult} result\n   */\n  updateUserSessionsFromResult(result) {\n    for (const scopeName in result.scopes) {\n      this.updateUserSessionScopeFromResult(scopeName, result.scopes[scopeName])\n    }\n  }\n\n  /**\n   * Applies one scope's signed-in state to the frontend Devise cache.\n   * @param {string} scopeName\n   * @param {SessionStatusScope} scope\n   */\n  updateUserSessionScopeFromResult(scopeName, scope) {\n    const deviseIsSignedInMethodName = `is${inflection.camelize(scopeName)}SignedIn`\n\n    if (!(deviseIsSignedInMethodName in Devise)) {\n      throw new Error(`No such method in Devise: ${deviseIsSignedInMethodName}`)\n    }\n\n    const currentlySignedIn = Devise[deviseIsSignedInMethodName]()\n    const signedInOnBackend = scope.signed_in\n\n    if (currentlySignedIn && !signedInOnBackend) {\n      logger.debug(() => `${inflection.camelize(scopeName)} signed in on frontend but not in backend!`)\n\n      Devise.setSignedOut({scope: scopeName})\n      Devise.callSignOutEvent({scope: scopeName})\n    }\n  }\n}\n"]}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@kaspernj/api-maker",
   "type": "module",
-  "version": "1.0.2172",
+  "version": "1.0.2173",
   "description": "My new module",
   "files": [
     "build/**"
@@ -11,7 +11,7 @@
   "scripts": {
     "build": "rm -rf build && tsc",
     "clean": "expo-module clean",
-    "lint": "expo-module lint -- --max-warnings 0",
+    "lint": "npm run eslint && npm run lint:eslint && npm run typecheck",
     "test": "NODE_OPTIONS=--experimental-vm-modules expo-module test",
     "prepare": "npm run clean && npm run build",
     "prepublishOnly": "expo-module prepublishOnly && npm run build",
@@ -22,7 +22,8 @@
     "release:patch-master": "node scripts/release-patch.js --require-master",
     "typecheck": "tsc --noEmit",
     "typecheck:file": "sh -c 'file=\"${npm_config_file:-${FILE:-}}\"; if [ -z \"$file\" ] && [ \"${0#--file=}\" != \"$0\" ]; then file=\"${0#--file=}\"; fi; if [ -z \"$file\" ] && [ \"${1#--file=}\" != \"$1\" ]; then file=\"${1#--file=}\"; fi; file=\"${file#npm-api-maker/}\"; file=\"${file#./}\"; if [ -z \"$file\" ]; then echo \"Missing --file=src/path/to/file.js\"; exit 2; fi; tmp=$(mktemp); tsc --noEmit -p tsconfig.json --pretty false >\"$tmp\" 2>&1; if rg --fixed-strings \"$file\" \"$tmp\" >/dev/null; then rg --fixed-strings \"$file\" \"$tmp\"; rm -f \"$tmp\"; exit 1; else rm -f \"$tmp\"; exit 0; fi'",
-    "watch": "tsc -w"
+    "watch": "tsc -w",
+    "eslint": "expo-module lint -- --max-warnings 0"
   },
   "keywords": [
     "react-native",