@saltcorn/mobile-app 1.7.0-alpha.0 → 1.7.0-alpha.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@saltcorn/mobile-app",
   "displayName": "Saltcorn mobile app",
-  "version": "1.7.0-alpha.0",
+  "version": "1.7.0-alpha.1",
   "description": "Saltcorn mobile app for Android and iOS",
   "main": "index.js",
   "scripts": {
@@ -16,7 +16,6 @@
   },
   "dependencies": {
     "universal-router": "9.2.1",
-    "axios": "0.32.0",
     "jwt-decode": "4.0.0",
     "i18next": "24.2.2",
     "i18next-sprintf-postprocessor": "0.2.2",

package/share_extension_files/Info.plist

@@ -2,6 +2,24 @@
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
+    <key>CFBundleDevelopmentRegion</key>
+    <string>en</string>
+    <key>CFBundleDisplayName</key>
+    <string>$(PRODUCT_NAME)</string>
+    <key>CFBundleExecutable</key>
+    <string>$(EXECUTABLE_NAME)</string>
+    <key>CFBundleIdentifier</key>
+    <string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+    <key>CFBundleInfoDictionaryVersion</key>
+    <string>6.0</string>
+    <key>CFBundleName</key>
+    <string>$(PRODUCT_NAME)</string>
+    <key>CFBundlePackageType</key>
+    <string>XPC!</string>
+    <key>CFBundleShortVersionString</key>
+    <string>$(MARKETING_VERSION)</string>
+    <key>CFBundleVersion</key>
+    <string>$(CURRENT_PROJECT_VERSION)</string>
     <key>NSExtension</key>
     <dict>
         <key>NSExtensionAttributes</key>
@@ -24,8 +42,8 @@
                     <false/>
                 </dict>
         </dict>
-        <key>NSExtensionMainStoryboard</key>
-        <string>MainInterface</string>
+        <key>NSExtensionPrincipalClass</key>
+        <string>$(PRODUCT_MODULE_NAME).ShareViewController</string>
         <key>NSExtensionPointIdentifier</key>
         <string>com.apple.share-services</string>
     </dict>

package/share_extension_files/ShareViewController.swift

@@ -10,89 +10,104 @@ import Social
 import UIKit
 
 class ShareItem {
-    
+
     public var title: String?
     public var type: String?
     public var url: String?
 }
 
 class ShareViewController: UIViewController {
-    
+
     private var shareItems: [ShareItem] = []
-    
-    override public func viewDidAppear(_ animated: Bool) {
-       super.viewDidAppear(animated)
-       self.extensionContext!.completeRequest(returningItems: [], completionHandler: nil)
-    }
-    
+
     private func sendData() {
+        // URLComponents.url already percent-encodes queryItems values when
+        // building the final URL string - encoding them here too caused
+        // double-encoding (e.g. "text/plain" arrived as "text%2Fplain"),
+        // which broke type checks like isFileItem() on the JS side.
         let queryItems = shareItems.map {
             [
-                URLQueryItem(
-                    name: "title",
-                    value: $0.title?.addingPercentEncoding(withAllowedCharacters: .urlHostAllowed) ?? ""),
+                URLQueryItem(name: "title", value: $0.title ?? ""),
                 URLQueryItem(name: "description", value: ""),
-                URLQueryItem(
-                    name: "type",
-                    value: $0.type?.addingPercentEncoding(withAllowedCharacters: .urlHostAllowed) ?? ""),
-                URLQueryItem(
-                    name: "url",
-                    value: $0.url?.addingPercentEncoding(withAllowedCharacters: .urlHostAllowed) ?? ""),
+                URLQueryItem(name: "type", value: $0.type ?? ""),
+                URLQueryItem(name: "url", value: $0.url ?? ""),
             ]
         }.flatMap({ $0 })
         var urlComps = URLComponents(string: "scappscheme://")!
         urlComps.queryItems = queryItems
         openURL(urlComps.url!)
     }
-    
+
     fileprivate func createSharedFileUrl(_ url: URL?) -> String {
-        let fileManager = FileManager.default
-        
-        let copyFileUrl =
-        fileManager.containerURL(forSecurityApplicationGroupIdentifier: "YOUR_APP_GROUP_ID")!
-            .absoluteString.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed)! + url!
-            .lastPathComponent.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed)!
-        try? Data(contentsOf: url!).write(to: URL(string: copyFileUrl)!)
-        
-        return copyFileUrl
+        guard let url = url else { return "" }
+        guard let containerURL = FileManager.default.containerURL(
+            forSecurityApplicationGroupIdentifier: "YOUR_APP_GROUP_ID"
+        ) else {
+            return ""
+        }
+        // appendingPathComponent handles escaping correctly on its own -
+        // hand-building a percent-encoded string here and then encoding it
+        // *again* as a URLQueryItem value in sendData() double-encoded it,
+        // so the path JS received didn't match any real file
+        let destinationURL = containerURL.appendingPathComponent(url.lastPathComponent)
+
+        // files vended by the Files app (iCloud, other apps' sandboxes) need
+        // this before they can actually be read - without it, Data(contentsOf:)
+        // fails and this used to silently return a path to a file that was
+        // never written
+        let didStartAccessing = url.startAccessingSecurityScopedResource()
+        defer {
+            if didStartAccessing { url.stopAccessingSecurityScopedResource() }
+        }
+        do {
+            try Data(contentsOf: url).write(to: destinationURL)
+            return destinationURL.absoluteString
+        } catch {
+            print("createSharedFileUrl failed: \(error)")
+            return ""
+        }
     }
-    
+
     func saveScreenshot(_ image: UIImage, _ index: Int) -> String {
-        let fileManager = FileManager.default
-        
-        let copyFileUrl =
-        fileManager.containerURL(forSecurityApplicationGroupIdentifier: "YOUR_APP_GROUP_ID")!
-            .absoluteString.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed)!
-        + "/screenshot_\(index).png"
+        guard let containerURL = FileManager.default.containerURL(
+            forSecurityApplicationGroupIdentifier: "YOUR_APP_GROUP_ID"
+        ) else {
+            return ""
+        }
+        let destinationURL = containerURL.appendingPathComponent("screenshot_\(index).png")
         do {
-            try image.pngData()?.write(to: URL(string: copyFileUrl)!)
-            return copyFileUrl
+            try image.pngData()?.write(to: destinationURL)
+            return destinationURL.absoluteString
         } catch {
-            print(error.localizedDescription)
+            print("saveScreenshot failed: \(error.localizedDescription)")
             return ""
         }
     }
-    
+
     fileprivate func handleTypeUrl(_ attachment: NSItemProvider)
     async throws -> ShareItem
     {
         let results = try await attachment.loadItem(forTypeIdentifier: kUTTypeURL as String, options: nil)
-        let url = results as! URL?
+        guard let url = results as? URL else {
+            throw NSError(domain: "ShareViewController", code: 1, userInfo: [
+                NSLocalizedDescriptionKey: "handleTypeUrl: expected a URL, got \(type(of: results))"
+            ])
+        }
         let shareItem: ShareItem = ShareItem()
-        
-        if url!.isFileURL {
-            shareItem.title = url!.lastPathComponent
-            shareItem.type = "application/" + url!.pathExtension.lowercased()
+
+        if url.isFileURL {
+            shareItem.title = url.lastPathComponent
+            shareItem.type = "application/" + url.pathExtension.lowercased()
             shareItem.url = createSharedFileUrl(url)
         } else {
-            shareItem.title = url!.absoluteString
-            shareItem.url = url!.absoluteString
+            shareItem.title = url.absoluteString
+            shareItem.url = url.absoluteString
             shareItem.type = "text/plain"
         }
-        
+
         return shareItem
     }
-    
+
     fileprivate func handleTypeText(_ attachment: NSItemProvider)
     async throws -> ShareItem
     {
@@ -103,25 +118,29 @@ class ShareViewController: UIViewController {
         shareItem.type = "text/plain"
         return shareItem
     }
-    
+
     fileprivate func handleTypeMovie(_ attachment: NSItemProvider)
     async throws -> ShareItem
     {
         let results = try await attachment.loadItem(forTypeIdentifier: kUTTypeMovie as String, options: nil)
         let shareItem: ShareItem = ShareItem()
-        
-        let url = results as! URL?
-        shareItem.title = url!.lastPathComponent
-        shareItem.type = "video/" + url!.pathExtension.lowercased()
+
+        guard let url = results as? URL else {
+            throw NSError(domain: "ShareViewController", code: 1, userInfo: [
+                NSLocalizedDescriptionKey: "handleTypeMovie: expected a URL, got \(type(of: results))"
+            ])
+        }
+        shareItem.title = url.lastPathComponent
+        shareItem.type = "video/" + url.pathExtension.lowercased()
         shareItem.url = createSharedFileUrl(url)
         return shareItem
     }
-    
+
     fileprivate func handleTypeImage(_ attachment: NSItemProvider, _ index: Int)
     async throws -> ShareItem
     {
         let data = try await attachment.loadItem(forTypeIdentifier: kUTTypeImage as String, options: nil)
-        
+
         let shareItem: ShareItem = ShareItem()
             switch data {
                 case let image as UIImage:
@@ -137,48 +156,58 @@ class ShareViewController: UIViewController {
         }
         return shareItem
     }
-    
+
     override public func viewDidLoad() {
         super.viewDidLoad()
-        
+
         shareItems.removeAll()
-        
+
         let extensionItem = extensionContext?.inputItems[0] as! NSExtensionItem
         Task {
-            try await withThrowingTaskGroup(
-                of: ShareItem.self,
-                body: { taskGroup in
-                    
-                    for (index, attachment) in extensionItem.attachments!.enumerated() {
-                        if attachment.hasItemConformingToTypeIdentifier(kUTTypeURL as String) {
-                            taskGroup.addTask {
-                                return try await self.handleTypeUrl(attachment)
-                            }
-                        } else if attachment.hasItemConformingToTypeIdentifier(kUTTypeText as String) {
-                            taskGroup.addTask {
-                                return try await self.handleTypeText(attachment)
-                            }
-                        } else if attachment.hasItemConformingToTypeIdentifier(kUTTypeMovie as String) {
-                            taskGroup.addTask {
-                                return try await self.handleTypeMovie(attachment)
-                            }
-                        } else if attachment.hasItemConformingToTypeIdentifier(kUTTypeImage as String) {
-                            taskGroup.addTask {
-                                return try await self.handleTypeImage(attachment, index)
+            do {
+                try await withThrowingTaskGroup(
+                    of: ShareItem.self,
+                    body: { taskGroup in
+
+                        for (index, attachment) in extensionItem.attachments!.enumerated() {
+                            if attachment.hasItemConformingToTypeIdentifier(kUTTypeURL as String) {
+                                taskGroup.addTask {
+                                    return try await self.handleTypeUrl(attachment)
+                                }
+                            } else if attachment.hasItemConformingToTypeIdentifier(kUTTypeText as String) {
+                                taskGroup.addTask {
+                                    return try await self.handleTypeText(attachment)
+                                }
+                            } else if attachment.hasItemConformingToTypeIdentifier(kUTTypeMovie as String) {
+                                taskGroup.addTask {
+                                    return try await self.handleTypeMovie(attachment)
+                                }
+                            } else if attachment.hasItemConformingToTypeIdentifier(kUTTypeImage as String) {
+                                taskGroup.addTask {
+                                    return try await self.handleTypeImage(attachment, index)
+                                }
                             }
                         }
-                    }
-                    
-                    for try await item in taskGroup {
-                        self.shareItems.append(item)
-                    }
-                })
-            
+
+                        for try await item in taskGroup {
+                            self.shareItems.append(item)
+                        }
+                    })
+            } catch {
+                // a bad attachment (e.g. an unexpected type) still needs to
+                // complete the request below, or the share sheet hangs
+                print("viewDidLoad: task group failed: \(error)")
+            }
+
             self.sendData()
-            
+            // only complete (letting the OS tear this extension down) once
+            // sendData() has actually handed off to the host app - doing
+            // this in viewDidAppear instead raced the async work above and
+            // usually won, killing the extension before openURL() ran
+            self.extensionContext!.completeRequest(returningItems: [], completionHandler: nil)
         }
     }
-    
+
     @objc func openURL(_ url: URL) {
         var responder: UIResponder? = self
         while responder != nil {
@@ -189,5 +218,5 @@ class ShareViewController: UIViewController {
             responder = responder?.next
         }
     }
-    
-}
+
+}

package/src/helpers/api.js

@@ -1,7 +1,5 @@
 /*global saltcorn, splashConfig*/
 
-import axios from "axios";
-import { jwtDecode } from "jwt-decode";
 import { router } from "../routing/index";
 import { replaceIframe, clearHistory } from "./navigation";
 
@@ -19,49 +17,83 @@ export async function apiCall({
       ? saltcorn.data.state.getState().mobileConfig
       : splashConfig;
   const serverPath = config.server_path;
-  const url = `${serverPath}${path}`;
+  let url = `${serverPath}${path}`;
+  if (params) {
+    const qs = new URLSearchParams(params).toString();
+    if (qs) url += `${url.includes("?") ? "&" : "?"}${qs}`;
+  }
   const headers = {
     "X-Requested-With": "XMLHttpRequest",
     "X-Saltcorn-Client": "mobile-app",
     ...(additionalHeaders || {}),
   };
   if (config.tenantAppName) headers["X-Saltcorn-App"] = config.tenantAppName;
-  const token = config.jwt;
-  if (token) {
-    try {
-      const decoded = jwtDecode(token);
-      if (decoded.exp && decoded.exp < Date.now() / 1000 && typeof saltcorn !== "undefined" && !path.startsWith("/auth/")) {
-        const mobileConfig = saltcorn.data.state.getState().mobileConfig;
-        mobileConfig.jwt = undefined;
-        await saltcorn.data.db.deleteWhere("jwt_table");
-        clearHistory();
-        const page = await router.resolve({
-          pathname: "get/auth/login",
-          alerts: [
-            { type: "warning", msg: "Your session has expired, please log in again." },
-          ],
-        });
-        await replaceIframe(page.content);
-        return;
-      }
-    } catch {
-      // malformed token, let the request proceed and fail naturally
-    }
-    headers.Authorization = `jwt ${token}`;
+  // The session cookie is attached automatically by the WebView (credentials: "include").
+  // The CSRF token has to be sent explicitly, same as the web client does.
+  if (config.csrfToken) headers["CSRF-Token"] = config.csrfToken;
+  const fetchOptions = { method, headers, credentials: "include" };
+  if (body !== undefined) {
+    fetchOptions.body = JSON.stringify(body);
+    headers["Content-Type"] = "application/json";
   }
+  const controller = timeout ? new AbortController() : null;
+  const timeoutId = controller
+    ? setTimeout(() => controller.abort(), timeout)
+    : null;
+  if (controller) fetchOptions.signal = controller.signal;
   try {
-    const result = await axios({
-      url: url,
-      method,
-      params,
-      headers,
-      responseType: responseType ? responseType : "json",
-      data: body,
-      timeout: timeout ? timeout : 0,
-    });
-    return result;
+    const res = await fetch(url, fetchOptions);
+    if (!res.ok) {
+      const error = new Error(`Request failed with status code ${res.status}`);
+      error.response = { status: res.status };
+      throw error;
+    }
+    let data;
+    if (responseType === "blob") data = await res.blob();
+    else if (responseType === "text") data = await res.text();
+    else {
+      // A redirected error page still counts as a 200 here, so parse by
+      // hand to give a clear error instead of a cryptic JSON parse failure.
+      const text = await res.text();
+      try {
+        data = text ? JSON.parse(text) : undefined;
+      } catch {
+        const error = new Error(
+          `Expected JSON but got ${
+            res.headers.get("content-type") || "unknown content-type"
+          } (status ${res.status}, url ${res.url})`
+        );
+        error.response = { status: res.status };
+        throw error;
+      }
+    }
+    return { data, status: res.status };
   } catch (error) {
+    if (
+      error.response?.status === 401 &&
+      typeof saltcorn !== "undefined" &&
+      !path.startsWith("/auth/")
+    ) {
+      const mobileConfig = saltcorn.data.state.getState().mobileConfig;
+      mobileConfig.csrfToken = undefined;
+      mobileConfig.hasSession = false;
+      await saltcorn.data.db.deleteWhere("session_table");
+      clearHistory();
+      const page = await router.resolve({
+        pathname: "get/auth/login",
+        alerts: [
+          {
+            type: "warning",
+            msg: "Your session has expired, please log in again.",
+          },
+        ],
+      });
+      await replaceIframe(page.content);
+      return;
+    }
     error.message = `Unable to call ${method} ${url}:\n${error.message}`;
     throw error;
+  } finally {
+    if (timeoutId) clearTimeout(timeoutId);
   }
 }

package/src/helpers/auth.js

@@ -1,6 +1,5 @@
 /*global saltcorn*/
 
-import { jwtDecode } from "jwt-decode";
 import i18next from "i18next";
 import { apiCall } from "./api";
 import { router } from "../routing/index";
@@ -15,50 +14,57 @@ import {
 } from "./common";
 
 /**
- * internal helper for the normal login/signup and public login
+ * fetches a CSRF token and caches it in mobileConfig.csrfToken.
+ * Call again after every login/logout, since both reset it.
+ */
+export async function refreshCsrfToken() {
+  const response = await apiCall({ method: "GET", path: "/auth/csrf-token" });
+  const config = saltcorn.data.state.getState().mobileConfig;
+  config.csrfToken = response?.data?.csrfToken;
+  return config.csrfToken;
+}
+
+/**
+ * internal helper for the normal login/signup
  * @param {any} param0
  * @returns
  */
-async function loginRequest({ email, password, isSignup, isPublic }) {
-  const opts = isPublic
+async function loginRequest({ email, password, isSignup, code }) {
+  await refreshCsrfToken();
+  const opts = code
     ? {
-        method: "GET",
-        path: "/auth/login-with/jwt",
+        method: "POST",
+        path: "/auth/session-from-code",
+        body: { code },
       }
     : isSignup
     ? {
         method: "POST",
         path: "/auth/signup",
-        body: {
-          email,
-          password,
-        },
+        body: { email, password },
       }
     : {
         method: "POST",
-        path: "/auth/login-with/jwt",
-        body: {
-          email,
-          password,
-        },
+        path: "/auth/login-with/session",
+        body: { email, password },
       };
   const response = await apiCall(opts);
   return response.data;
 }
 
 /**
- * internal helper to process a JWT token
- * @param {string} tokenStr
+ * internal helper to process a successful session login response
+ * ({ success: true, user }) and persist it locally
  */
-const handleToken = async (tokenStr, config) => {
-  const token = jwtDecode(tokenStr);
-  const user = token.user;
+const handleSessionLogin = async (user, config) => {
   config.user = user;
   config.isPublicUser = false;
   config.isOfflineMode = false;
+  config.hasSession = true;
   await insertUser(user);
-  await setJwt(tokenStr);
-  config.jwt = tokenStr;
+  // login regenerated the session, so the previously fetched token is stale
+  await refreshCsrfToken();
+  await persistSession(config);
   i18next.changeLanguage(user.language);
 };
 
@@ -101,22 +107,22 @@ const getEntryPoint = (config) => {
 };
 
 /**
- * For normal login/signup email and password are used
- * When called from auth provider login (see google-auth plugin), token is used
+ * Normal login/signup use email and password. An OAuth-provider login
+ * (e.g. google-auth's finishLogin) instead passes the short-lived code
+ * its deep-link callback was handed, which stands in for a session here.
  * @param {*} param0
  */
 export async function login({ email, password, isSignup, token }) {
-  const loginResult = !token
-    ? await loginRequest({
-        email,
-        password,
-        isSignup,
-      })
-    : token;
-  if (typeof loginResult === "string") {
+  const loginResult = await loginRequest({
+    email,
+    password,
+    isSignup,
+    code: token,
+  });
+  if (loginResult?.success && loginResult?.user) {
     const alerts = [];
     const config = saltcorn.data.state.getState().mobileConfig;
-    await handleToken(loginResult, config);
+    await handleSessionLogin(loginResult.user, config);
     if (config.allowOfflineMode) alerts.push(await initialSync(config));
     await tryInitPush(config);
     await tryInitBackgroundSync(config);
@@ -129,14 +135,31 @@ export async function login({ email, password, isSignup, token }) {
     });
 
     // open first page
-    const entryPoint = getEntryPoint(config);
-    addRoute({ route: entryPoint, query: undefined });
-    const page = await router.resolve({
-      pathname: entryPoint,
-      fullWrap: true,
-      alerts,
-    });
-    if (page.content) await replaceIframe(page.content, page.isFile);
+    try {
+      const entryPoint = getEntryPoint(config);
+      addRoute({ route: entryPoint, query: undefined });
+      const page = await router.resolve({
+        pathname: entryPoint,
+        fullWrap: true,
+        alerts,
+      });
+      if (page.content) await replaceIframe(page.content, page.isFile);
+    } catch (error) {
+      // Logged in fine, but this user can't open the app's entry point
+      // (e.g. its role doesn't allow it) - say so instead of leaving
+      // them stuck on the login page with no explanation.
+      showToasts([
+        {
+          type: "error",
+          msg: i18next.t("Logged in as %s, but unable to open the app: %s", {
+            postProcess: "sprintf",
+            sprintf: [config.user.email, error.message || "unknown error"],
+          }),
+        },
+      ]);
+    }
+  } else if (loginResult?.error) {
+    showToasts([{ type: "error", msg: loginResult.error }]);
   } else if (loginResult?.alerts) {
     showToasts(loginResult?.alerts);
   } else {
@@ -146,44 +169,39 @@ export async function login({ email, password, isSignup, token }) {
 
 export async function publicLogin(entryPoint) {
   try {
-    const loginResult = await loginRequest({ isPublic: true });
-    if (typeof loginResult === "string") {
-      const config = saltcorn.data.state.getState().mobileConfig;
-      config.user = {
-        role_id: 100,
-        email: "public",
-        language: "en",
-      };
-      config.isPublicUser = true;
-      await setJwt(loginResult);
-      config.jwt = loginResult;
-      i18next.changeLanguage(config.user.language);
-      addRoute({
-        route: entryPoint,
-        query: undefined,
-      });
-      const page = await router.resolve({
-        pathname: entryPoint,
-        fullWrap: true,
-        alerts: [
-          {
-            type: "success",
-            msg: i18next.t("Welcome to %s!", {
-              postProcess: "sprintf",
-              sprintf: [
-                saltcorn.data.state.getState().getConfig("site_name") ||
-                  "Saltcorn",
-              ],
-            }),
-          },
-        ],
-      });
-      if (page.content) await replaceIframe(page.content, page.isFile);
-    } else if (loginResult?.alerts) {
-      showToasts(loginResult?.alerts);
-    } else {
-      throw new Error("The login failed.");
-    }
+    const config = saltcorn.data.state.getState().mobileConfig;
+    // no login needed for public, but a CSRF token is still cached upfront.
+    await refreshCsrfToken();
+    config.user = {
+      role_id: 100,
+      email: "public",
+      language: "en",
+    };
+    config.isPublicUser = true;
+    config.hasSession = true;
+    await persistSession(config);
+    i18next.changeLanguage(config.user.language);
+    addRoute({
+      route: entryPoint,
+      query: undefined,
+    });
+    const page = await router.resolve({
+      pathname: entryPoint,
+      fullWrap: true,
+      alerts: [
+        {
+          type: "success",
+          msg: i18next.t("Welcome to %s!", {
+            postProcess: "sprintf",
+            sprintf: [
+              saltcorn.data.state.getState().getConfig("site_name") ||
+                "Saltcorn",
+            ],
+          }),
+        },
+      ],
+    });
+    if (page.content) await replaceIframe(page.content, page.isFile);
   } catch (error) {
     console.error(error);
     showToasts([
@@ -203,9 +221,11 @@ export async function logout() {
     await tryStopBackgroundSync();
     const response = await apiCall({ method: "GET", path: "/auth/logout" });
     if (response.data.success) {
-      await removeJwt();
+      await clearSession();
       clearHistory();
-      config.jwt = undefined;
+      config.csrfToken = undefined;
+      config.hasSession = false;
+      config.isPublicUser = false;
       const page = await router.resolve({
         pathname: "get/auth/login",
         entryView: config.entry_point,
@@ -232,43 +252,34 @@ export async function insertUser({ id, email, role_id, language }) {
   );
 }
 
-export async function removeJwt() {
-  await saltcorn.data.db.deleteWhere("jwt_table");
+export async function clearSession() {
+  await saltcorn.data.db.deleteWhere("session_table");
 }
 
-export async function setJwt(jwt) {
-  await removeJwt();
-  await saltcorn.data.db.insert("jwt_table", { jwt: jwt });
-}
-
-async function renewJwt() {
-  try {
-    const response = await apiCall({
-      method: "POST",
-      path: "/auth/renew-jwt",
-    });
-    if (typeof response.data === "string") {
-      const config = saltcorn.data.state.getState().mobileConfig;
-      await setJwt(response.data);
-      config.jwt = response.data;
-    }
-  } catch (e) {
-    console.error("JWT renewal failed:", e.message);
-  }
+/**
+ * persists the current mobileConfig session state (csrf token, user,
+ * public/authenticated flag) so the app can restore it at next boot
+ * without a network call (used e.g. when starting offline).
+ */
+export async function persistSession(config) {
+  await clearSession();
+  await saltcorn.data.db.insert("session_table", {
+    csrfToken: config.csrfToken,
+    userJson: config.isPublicUser ? null : JSON.stringify(config.user),
+    isPublicUser: !!config.isPublicUser,
+  });
 }
 
-export async function checkJWT(jwtStr) {
-  if (jwtStr && jwtStr !== "undefined") {
-    const response = await apiCall({
-      method: "GET",
-      path: "/auth/authenticated",
-      timeout: 10000,
-    });
-    if (!response.data.authenticated) return false;
-    const decoded = jwtDecode(jwtStr);
-    if (decoded.exp && decoded.exp - Date.now() / 1000 < 7 * 24 * 3600) {
-      await renewJwt();
-    }
-    return true;
-  } else return false;
+/**
+ * checks with the server whether the current session cookie is still valid,
+ * and refreshes the cached CSRF token (its secret lives in the session, so
+ * it's fine to keep reusing the same token as long as the session is alive).
+ */
+export async function checkSession() {
+  const response = await apiCall({
+    method: "GET",
+    path: "/auth/authenticated",
+    timeout: 10000,
+  });
+  return !!response?.data?.authenticated;
 }

package/src/helpers/db_schema.js

@@ -1,7 +1,7 @@
 /*global saltcorn */
 
 const historyFile = "update_history";
-const jwtTableName = "jwt_table";
+const sessionTableName = "session_table";
 
 import { readFile, fileExists, writeJSON } from "./file_system";
 import { Directory } from "@capacitor/filesystem";
@@ -206,8 +206,10 @@ export async function updateDb(tablesJSON) {
   });
 }
 
-export async function createJwtTable() {
-  await saltcorn.data.db.query(`CREATE TABLE IF NOT EXISTS ${jwtTableName} (
-    jwt VARCHAR(500)
+export async function createSessionTable() {
+  await saltcorn.data.db.query(`CREATE TABLE IF NOT EXISTS ${sessionTableName} (
+    csrfToken VARCHAR(500),
+    userJson VARCHAR(2000),
+    isPublicUser BOOLEAN
   )`);
 }

package/src/helpers/file_system.js

@@ -1,4 +1,7 @@
 import { Filesystem, Encoding, Directory } from "@capacitor/filesystem";
+// side-effect only: registers the plugin so it works on the web platform too,
+// same as Filesystem above (native platforms pick it up either way)
+import "@capacitor/file-transfer";
 
 export async function writeFile(name, directory, content) {
   try {

package/src/helpers/offline_mode.js

@@ -59,11 +59,11 @@ const insertRemoteData = async (table, rows, syncTimestamp) => {
     const ref = _sync_info_tbl_ref_,
       last_modified = _sync_info_tbl_last_modified_;
     await saltcorn.data.db.insert(tblName, rest, { replace: true });
-    const infos = await saltcorn.data.db.select(
-      `${saltcorn.data.db.sqlsanitize(tblName)}_sync_info`,
-      {
-        ref: String(rest[pkName]),
-      }
+    // ref is inlined as a literal, not passed as a param, so numeric-looking
+    // refs like "19" don't get silently turned into "19.0" on iOS.
+    const { rows: infos } = await saltcorn.data.db.query(
+      `select 1 from "${saltcorn.data.db.sqlsanitize(tblName)}_sync_info"
+         where ref=${sqlRef(rest[pkName])}`
     );
     if (infos.length > 0) {
       await saltcorn.data.db.query(
@@ -72,14 +72,10 @@ const insertRemoteData = async (table, rows, syncTimestamp) => {
                where ref=${sqlRef(rest[pkName])}`
       );
     } else {
-      await saltcorn.data.db.insert(
-        `${saltcorn.data.db.sqlsanitize(tblName)}_sync_info`,
-        {
-          ref: String(ref),
-          last_modified: syncTimestamp,
-          deleted: false,
-          modified_local: false,
-        }
+      await saltcorn.data.db.query(
+        `insert into "${saltcorn.data.db.sqlsanitize(tblName)}_sync_info"
+           (ref, last_modified, deleted, modified_local)
+           values (${sqlRef(ref)}, ${syncTimestamp}, false, false)`
       );
     }
   }

package/src/index.js

@@ -1,4 +1,4 @@
-import { init } from "./init";
+import { init, postShare } from "./init";
 import * as api from "./helpers/api";
 import * as auth from "./helpers/auth";
 import * as common from "./helpers/common";
@@ -12,7 +12,7 @@ import { router } from "./routing/index";
 let notifications = undefined;
 try {
   notifications = require("./helpers/notifications");
-  console.log("Notifications module available");  
+  console.log("Notifications module available");
 } catch (err) {
   console.log("Notifications module not available");
 }
@@ -21,9 +21,8 @@ try {
 let backgroundSync = undefined;
 try {
   backgroundSync = require("./helpers/background_sync");
-  console.log("Background sync module available");  
-}
-catch (err) {
+  console.log("Background sync module available");
+} catch (err) {
   console.log("Background sync module not available");
 }
 
@@ -38,6 +37,7 @@ context.keys().forEach((key) => {
 
 export const mobileApp = {
   init,
+  postShare,
   api,
   auth,
   common,

package/src/init.js

@@ -11,9 +11,9 @@ import {
   createSyncInfoTables,
   dbUpdateNeeded,
   updateDb,
-  createJwtTable,
+  createSessionTable,
 } from "./helpers/db_schema.js";
-import { publicLogin, checkJWT } from "./helpers/auth.js";
+import { publicLogin, checkSession } from "./helpers/auth.js";
 import { router } from "./routing/index.js";
 import {
   replaceIframe,
@@ -30,7 +30,6 @@ import { readJSONCordova, readTextCordova } from "./helpers/file_system.js";
 
 import i18next from "i18next";
 import i18nextSprintfPostProcessor from "i18next-sprintf-postprocessor";
-import { jwtDecode } from "jwt-decode";
 
 import { Network } from "@capacitor/network";
 import { App } from "@capacitor/app";
@@ -152,19 +151,34 @@ const handlePluginHeaders = async (plugins) => {
   }
 };
 
-const getJwt = async () => {
-  const rows = await saltcorn.data.db.select("jwt_table");
-  return rows?.length > 0 ? rows[0].jwt : null;
+const getSession = async () => {
+  const rows = await saltcorn.data.db.select("session_table");
+  return rows?.length > 0 ? rows[0] : null;
 };
 
-const initJwt = async () => {
-  if (!(await saltcorn.data.db.tableExists("jwt_table"))) {
-    await createJwtTable();
+const initSession = async () => {
+  if (!(await saltcorn.data.db.tableExists("session_table"))) {
+    await createSessionTable();
   } else {
-    const jwt = await getJwt();
-    if (jwt) {
+    const row = await getSession();
+    if (row?.csrfToken) {
       const state = saltcorn.data.state.getState();
-      state.mobileConfig.jwt = jwt;
+      state.mobileConfig.csrfToken = row.csrfToken;
+      state.mobileConfig.isPublicUser = !!row.isPublicUser;
+      state.mobileConfig.hasSession = true;
+      if (row.isPublicUser) {
+        state.mobileConfig.user = {
+          role_id: 100,
+          email: "public",
+          language: "en",
+        };
+      } else if (row.userJson) {
+        try {
+          state.mobileConfig.user = JSON.parse(row.userJson);
+        } catch {
+          // corrupted local row, fall back to a network check
+        }
+      }
     }
   }
 };
@@ -210,7 +224,7 @@ const showErrorPage = async (error) => {
 const onResume = async () => {
   if (typeof saltcorn === "undefined") return;
   const mobileConfig = saltcorn.data.state.getState().mobileConfig;
-  if (mobileConfig?.jwt) {
+  if (mobileConfig?.hasSession) {
     const netStatus = await Network.getStatus();
     mobileConfig.networkState = netStatus.connectionType;
     if (
@@ -226,8 +240,8 @@ const onResume = async () => {
         await showErrorPage(error);
       }
     } else if (mobileConfig.networkState !== "none") {
-      if (!mobileConfig.isOfflineMode && !isPublicJwt(mobileConfig.jwt)) {
-        await checkJWT(mobileConfig.jwt);
+      if (!mobileConfig.isOfflineMode && !mobileConfig.isPublicUser) {
+        await checkSession();
       }
       if (mobileConfig.allowOfflineMode && mobileConfig.syncOnAppResume) {
         try {
@@ -240,21 +254,6 @@ const onResume = async () => {
   }
 };
 
-const isPublicJwt = (jwt) => {
-  try {
-    if (!jwt) return false;
-    const decoded = jwtDecode(jwt);
-    return decoded.sub === "public";
-  } catch (error) {
-    console.log(
-      `Unable to inspect '${jwt}': ${
-        error.message ? error.message : "Unknown error"
-      }`
-    );
-    return false;
-  }
-};
-
 const isPublicEntryPoint = async (entryPoint) => {
   if (!entryPoint) return false;
   try {
@@ -309,7 +308,7 @@ const notEmpty = (shareData) => {
   }
 };
 
-const postShare = async (shareData) => {
+export const postShare = async (shareData) => {
   const page = await router.resolve({
     pathname: "post/notifications/share",
     shareData,
@@ -390,7 +389,7 @@ export async function init(mobileConfig) {
       try {
         const url = event.url;
         if (url.startsWith("mobileapp://auth/callback")) {
-          const token = new URL(url).searchParams.get("token");
+          const token = new URL(url).searchParams.get("code");
           const method = new URL(url).searchParams.get("method");
           const methods = saltcorn.data.state.getState().auth_methods;
           if (!methods[method])
@@ -429,7 +428,7 @@ export async function init(mobileConfig) {
       await updateDb(tablesJSON);
     }
     await createSyncInfoTables(mobileConfig.synchedTables);
-    await initJwt();
+    await initSession();
     await state.refresh_tables();
     await state.refresh_views();
     await state.refresh_pages();
@@ -455,14 +454,16 @@ export async function init(mobileConfig) {
     Network.addListener("networkStatusChange", networkChangeCallback);
 
     const networkDisabled = state.mobileConfig.networkState === "none";
-    const jwt = state.mobileConfig.jwt;
+    const hasSession = !!state.mobileConfig.hasSession;
+    const isPublicUser = !!state.mobileConfig.isPublicUser;
     const alerts = [];
-    if ((networkDisabled && jwt) || (await checkJWT(jwt))) {
-      // already logged in, continue
+    if (
+      hasSession &&
+      !isPublicUser &&
+      (networkDisabled || (await checkSession()))
+    ) {
+      // already logged in, continue - mobileConfig.user was restored by initSession()
       const mobileConfig = state.mobileConfig;
-      const decodedJwt = jwtDecode(mobileConfig.jwt);
-      mobileConfig.user = decodedJwt.user;
-      mobileConfig.isPublicUser = false;
       await i18next.changeLanguage(mobileConfig.user.language);
       if (mobileConfig.allowOfflineMode) {
         const { offlineUser } = (await getLastOfflineSession()) || {};
@@ -536,11 +537,9 @@ export async function init(mobileConfig) {
         });
       }
       if (page.content) await replaceIframe(page.content, page.isFile);
-    } else if (isPublicJwt(jwt)) {
+    } else if (hasSession && isPublicUser) {
       // already logged in as public
       const config = state.mobileConfig;
-      config.user = { role_id: 100, email: "public", language: "en" };
-      config.isPublicUser = true;
       i18next.changeLanguage(config.user.language);
       const entryPoint = getEntryPoint(100, state, state.mobileConfig);
       if (!entryPoint) await showLogin(alerts);

package/src/routing/mocks/request.js

@@ -29,7 +29,7 @@ export function MobileRequest({
       }),
     isAuthenticated: () => {
       const mobileCfg = saltcorn.data.state.getState().mobileConfig;
-      return mobileCfg && mobileCfg.jwt && !mobileCfg.isPublicUser;
+      return mobileCfg && mobileCfg.hasSession && !mobileCfg.isPublicUser;
     },
     getLocale: () => {
       const mobileCfg = saltcorn.data.state.getState().mobileConfig;

package/src/routing/routes/notifications.js

@@ -3,7 +3,7 @@
 import { wrapContents } from "../utils";
 import { MobileRequest } from "../mocks/request";
 
-import { checkJWT } from "../../helpers/auth.js";
+import { checkSession } from "../../helpers/auth.js";
 import { apiCall } from "../../helpers/api";
 
 const buildErrMsg = (msg) => {
@@ -24,21 +24,45 @@ const buildSuccessMsg = (msg) => {
   );
 };
 
+// files have a real type (e.g. image/png); text/link shares are "text/plain"
+const isFileItem = (item) =>
+  item?.type && item.type !== "text/plain" && item.url;
+
 export const postShare = async (context) => {
   let content = "";
   const mobileCfg = saltcorn.data.state.getState().mobileConfig;
   if (mobileCfg.networkState === "none")
     content = buildErrMsg("No network connection");
-  else if (!(await checkJWT(mobileCfg.jwt)))
-    content = buildErrMsg("Not authenticated");
+  else if (!(await checkSession())) content = buildErrMsg("Not authenticated");
   else {
-    const response = await apiCall({
-      method: "POST",
-      path: "/notifications/share-handler",
-      body: context.shareData,
-    });
-    if (response.error) content = buildErrMsg(response.error);
-    else content = buildSuccessMsg("Shared successfully");
+    try {
+      const { title, description, type, url, additionalItems } =
+        context.shareData || {};
+      let body = context.shareData;
+      if (isFileItem({ type, url })) {
+        const items = [{ title, type, url }, ...(additionalItems || [])];
+        // title is the real on-disk filename, location is where to find it
+        const files = [];
+        for (const item of items) {
+          const uploaded = await saltcorn.data.models.File.uploadFromPath(
+            item.url,
+            item.title || "shared-file",
+            item.type
+          );
+          files.push({ title: uploaded.filename, location: uploaded.location });
+        }
+        body = { description, files };
+      }
+      const response = await apiCall({
+        method: "POST",
+        path: "/notifications/share-handler",
+        body,
+      });
+      if (response.error) content = buildErrMsg(response.error);
+      else content = buildSuccessMsg("Shared successfully");
+    } catch (error) {
+      content = buildErrMsg(error.message || "Error sharing");
+    }
   }
   return await wrapContents(
     saltcorn.markup.tags.div(

package/src/routing/routes/view.js

@@ -39,7 +39,7 @@ export const postView = async (context) => {
   const mobileCfg = state.mobileConfig;
   if (
     mobileCfg.user.role_id > view.min_role &&
-    !(await view.authorise_post({ body, req, ...view }))
+    !(await view.authorize(mobileCfg.user, { action: "post", req, body }))
   ) {
     throw new saltcorn.data.utils.NotAuthorized(req.__("Not authorized"));
   }
@@ -150,7 +150,11 @@ export const getView = async (context) => {
   if (!view) throw new Error(req.__("No such view: %s", viewname));
   if (
     state.mobileConfig.user.role_id > view.min_role &&
-    !(await view.authorise_get({ query, req, ...view }))
+    !(await view.authorize(state.mobileConfig.user, {
+      action: "get",
+      req,
+      state: query,
+    }))
   ) {
     const additionalInfos = `: your role: ${state.mobileConfig.user.role_id}, view min_role: ${view.min_role}`;
     throw new saltcorn.data.utils.NotAuthorized(
@@ -161,7 +165,9 @@ export const getView = async (context) => {
   if (!view.renderLocally()) {
     const response = await apiCall({
       method: "GET",
-      path: `/view/${encodeURIComponent(viewname)}${context.query ? `?${context.query}` : ""}`,
+      path: `/view/${encodeURIComponent(viewname)}${
+        context.query ? `?${context.query}` : ""
+      }`,
     });
     const data = response.data;
     contents0 = data;

package/src/routing/utils.js

@@ -24,7 +24,7 @@ export const getHeaders = () => {
     from_cfg.push({ style: state.getConfig("page_custom_css", "") });
   if (state.getConfig("page_custom_html", ""))
     from_cfg.push({ headerTag: state.getConfig("page_custom_html", "") });
-  return [...stdHeaders, ...config.pluginHeaders, ...from_cfg];
+  return [...stdHeaders, ...(config.pluginHeaders || []), ...from_cfg];
 };
 
 export const parseQuery = (queryStr) => {

package/www/js/iframe_view_utils.js

@@ -1,6 +1,21 @@
 /*eslint-env browser*/
 /*global $, KTDrawer, reload_embedded_view, submitWithEmptyAction, is_paging_param, bootstrap, common_done, unique_field_from_rows, inline_submit_success, get_current_state_url, initialize_page, reset_spinners */
 
+// Tapping a javascript: link silently does nothing on iOS, so we run the
+// code ourselves instead of relying on the link to do it.
+document.addEventListener("click", function (event) {
+  const link =
+    event.target.closest && event.target.closest("a[href^='javascript:']");
+  if (!link) return;
+  event.preventDefault();
+  const code = link.getAttribute("href").slice("javascript:".length);
+  try {
+    (0, eval)(code);
+  } catch (error) {
+    console.error("Error executing javascript: link:", error);
+  }
+});
+
 function combineFormAndQuery(form, query) {
   let paramsList = [];
   const formData = new FormData(form[0]);
@@ -87,7 +102,10 @@ async function formSubmit(e, urlSuffix, viewname, noSubmitCb, matchingState) {
     const urlParams = new URLSearchParams();
     const data = matchingState ? {} : null;
     for (const entry of new FormData(e).entries()) {
-      if (entry[1] instanceof File) files[entry[0]] = entry[1];
+      // cordova-plugin-file replaces window.File with its own class, so a
+      // real picked file no longer passes "instanceof File" - Blob still
+      // works, since every File is also a Blob.
+      if (entry[1] instanceof Blob) files[entry[0]] = entry[1];
       else {
         // is there a hidden input with a filename?
         const domEl = $(e).find(
@@ -431,22 +449,50 @@ async function pjax_to(href, query, e) {
     await parent.saltcorn.mobileApp.navigation.handleRoute(safeHref, query);
   else
     try {
-      const headers = {
-        pjaxpageload: "true",
-      };
-      if (localizer.length) headers.localizedstate = "true";
-      const result = await parent.saltcorn.mobileApp.api.apiCall({
-        path: path,
-        method: "GET",
-        additionalHeaders: headers,
-      });
+      const { isOfflineMode } =
+        parent.saltcorn.data.state.getState().mobileConfig;
+      let content;
+      if (isOfflineMode) {
+        const page = await parent.saltcorn.mobileApp.navigation.router.resolve(
+          {
+            pathname: `get${safeHref}`,
+            query: query,
+          }
+        );
+        if (page.redirect) {
+          const { path: redirectPath, query: redirectQuery } =
+            parent.saltcorn.mobileApp.navigation.splitPathQuery(
+              page.redirect
+            );
+          await parent.saltcorn.mobileApp.navigation.handleRoute(
+            redirectPath.startsWith("/") && redirectPath.length > 1
+              ? `get${redirectPath}`
+              : redirectPath,
+            redirectQuery
+          );
+          return;
+        }
+        content = typeof page === "string" ? page : page.content;
+      } else {
+        const headers = {
+          pjaxpageload: "true",
+        };
+        if (localizer.length) headers.localizedstate = "true";
+        const result = await parent.saltcorn.mobileApp.api.apiCall({
+          path: path,
+          method: "GET",
+          additionalHeaders: headers,
+          responseType: "text",
+        });
+        content = result.data;
+      }
       if (!inModal && !localizer.length) {
         // not sure for mobile
         // window.history.pushState({ url: href }, "", href);
       }
       if (inModal && !localizer.length)
         $(".sc-modal-linkout").attr("href", path);
-      $dest.html(result.data);
+      $dest.html(content);
       if (localizer.length) localizer.attr("data-sc-local-state", path);
       initialize_page();
     } catch (error) {
@@ -675,17 +721,16 @@ async function make_unique_field(
   }
 }
 
-function openFile(fileId) {
+async function openFile(fileId) {
   const config = parent.saltcorn.data.state.getState().mobileConfig;
   const serverPath = config.server_path;
-  const token = config.jwt;
-  const url = `${serverPath}/files/serve/${encodeURIComponent(
-    fileId
-  )}?jwt=${token}`;
+  const url = `${serverPath}/files/serve/${encodeURIComponent(fileId)}`;
   parent.cordova.InAppBrowser.open(
     url,
     "_blank",
-    "clearcache=yes,clearsessioncache=yes,location=no,toolbar=yes,toolbarposition=top"
+    // No clearcache - it clears cookies app-wide (Android's cookie store
+    // isn't scoped per tab), which would log the main app out too.
+    "location=no,toolbar=yes,toolbarposition=top"
   );
 }
 
@@ -695,7 +740,9 @@ function openInAppBrowser(url, domId) {
     const ref = parent.cordova.InAppBrowser.open(
       url,
       "_blank",
-      "clearcache=yes,clearsessioncache=yes,location=no,toolbar=yes,toolbarposition=top"
+      // No clearcache - it clears cookies app-wide (Android's cookie store
+      // isn't scoped per tab), which would log the main app out too.
+      "location=no,toolbar=yes,toolbarposition=top"
     );
     ref.addEventListener("exit", function () {
       $(`#${domId}`).find(".spinner-border").addClass("d-none");