@saltcorn/mobile-app 1.6.0-beta.5 → 1.6.0-beta.6

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@saltcorn/mobile-app",
   "displayName": "Saltcorn mobile app",
-  "version": "1.6.0-beta.5",
+  "version": "1.6.0-beta.6",
   "description": "Saltcorn mobile app for Android and iOS",
   "main": "index.js",
   "scripts": {

package/src/helpers/db_schema.js

@@ -102,49 +102,77 @@ export async function updateUserDefinedTables() {
   }
 }
 
+const createSyncInfoIndexes = async (safeName) => {
+  const tbl = `${safeName}_sync_info`;
+  await saltcorn.data.db.query(
+    `CREATE INDEX IF NOT EXISTS ${tbl}_ref_index ON ${tbl}(ref)`
+  );
+  await saltcorn.data.db.query(
+    `CREATE INDEX IF NOT EXISTS ${tbl}_lm_index ON ${tbl}(last_modified)`
+  );
+  await saltcorn.data.db.query(
+    `CREATE INDEX IF NOT EXISTS ${tbl}_deleted_index ON ${tbl}(deleted)`
+  );
+  await saltcorn.data.db.query(
+    `CREATE INDEX IF NOT EXISTS ${tbl}_ml_index ON ${tbl}(modified_local)`
+  );
+};
+
+// Each entry migrates sync_info tables from version (index) to version (index + 1).
+// To add a migration: append a function and bump SYNC_INFO_SCHEMA_VERSION.
+const SYNC_INFO_SCHEMA_VERSION = 1;
+
+const syncInfoMigrations = [
+  // v0 → v1: ref integer → ref text (UUID primary key support)
+  // SQLite does not support ALTER COLUMN, so we rename → recreate → copy → drop
+  async (safeName) => {
+    const tbl = `${safeName}_sync_info`;
+    const tmp = `${tbl}_migrate_tmp`;
+    await saltcorn.data.db.query(`ALTER TABLE "${tbl}" RENAME TO "${tmp}"`);
+    await saltcorn.data.db.query(`CREATE TABLE "${tbl}" (
+      ref text,
+      last_modified timestamp,
+      deleted integer,
+      modified_local integer
+    )`);
+    await saltcorn.data.db.query(
+      `INSERT INTO "${tbl}" (ref, last_modified, deleted, modified_local)
+       SELECT CAST(ref AS TEXT), last_modified, deleted, modified_local FROM "${tmp}"`
+    );
+    await saltcorn.data.db.query(`DROP TABLE "${tmp}"`);
+    await createSyncInfoIndexes(safeName);
+  },
+];
+
+export async function migrateSyncInfoTables(synchTbls) {
+  const state = saltcorn.data.state.getState();
+  const currentVersion =
+    (await state.getConfig("sync_info_schema_version")) ?? -1;
+  if (currentVersion >= SYNC_INFO_SCHEMA_VERSION) return;
+  for (const synchTbl of synchTbls) {
+    const safeName = saltcorn.data.db.sqlsanitize(synchTbl);
+    if (!(await saltcorn.data.db.tableExists(`${safeName}_sync_info`)))
+      continue;
+    for (let v = currentVersion + 1; v <= SYNC_INFO_SCHEMA_VERSION; v++) {
+      await syncInfoMigrations[v - 1]?.(safeName);
+    }
+  }
+  await state.setConfig("sync_info_schema_version", SYNC_INFO_SCHEMA_VERSION);
+}
+
 export async function createSyncInfoTables(synchTbls) {
-  const infoTbls = (await saltcorn.data.db.listTables()).filter(({ name }) => {
-    name.endsWith("_sync_info");
-  });
+  await migrateSyncInfoTables(synchTbls);
   for (const synchTbl of synchTbls) {
-    if (!infoTbls.find(({ name }) => name.startsWith(synchTbl))) {
-      await saltcorn.data.db
-        .query(`CREATE TABLE IF NOT EXISTS ${saltcorn.data.db.sqlsanitize(
-        synchTbl
-      )}_sync_info (
-          ref integer,
-          last_modified timestamp,
-          deleted integer,
-          modified_local integer
+    const safeName = saltcorn.data.db.sqlsanitize(synchTbl);
+    const tblName = `${safeName}_sync_info`;
+    if (!(await saltcorn.data.db.tableExists(tblName))) {
+      await saltcorn.data.db.query(`CREATE TABLE IF NOT EXISTS ${tblName} (
+        ref text,
+        last_modified timestamp,
+        deleted integer,
+        modified_local integer
       )`);
-      await saltcorn.data.db.query(
-        `CREATE INDEX IF NOT EXISTS ${saltcorn.data.db.sqlsanitize(
-          synchTbl
-        )}_sync_info_ref_index on ${saltcorn.data.db.sqlsanitize(
-          synchTbl
-        )}_sync_info(ref);`
-      );
-      await saltcorn.data.db.query(
-        `CREATE INDEX IF NOT EXISTS ${saltcorn.data.db.sqlsanitize(
-          synchTbl
-        )}_sync_info_lm_index on ${saltcorn.data.db.sqlsanitize(
-          synchTbl
-        )}_sync_info(last_modified);`
-      );
-      await saltcorn.data.db.query(
-        `CREATE INDEX IF NOT EXISTS ${saltcorn.data.db.sqlsanitize(
-          synchTbl
-        )}_sync_info_deleted_index on ${saltcorn.data.db.sqlsanitize(
-          synchTbl
-        )}_sync_info(deleted);`
-      );
-      await saltcorn.data.db.query(
-        `CREATE INDEX IF NOT EXISTS ${saltcorn.data.db.sqlsanitize(
-          synchTbl
-        )}_sync_info_ml_index on ${saltcorn.data.db.sqlsanitize(
-          synchTbl
-        )}_sync_info(modified_local);`
-      );
+      await createSyncInfoIndexes(safeName);
     }
   }
 }
@@ -178,12 +206,6 @@ export async function updateDb(tablesJSON) {
   });
 }
 
-export async function getTableIds(tableNames) {
-  return (await saltcorn.data.models.Table.find())
-    .filter((table) => tableNames.indexOf(table.name) > -1)
-    .map((table) => table.id);
-}
-
 export async function createJwtTable() {
   await saltcorn.data.db.query(`CREATE TABLE IF NOT EXISTS ${jwtTableName} (
     jwt VARCHAR(500)

package/src/helpers/offline_mode.js

@@ -11,6 +11,9 @@ import {
   removeLoadSpinner,
 } from "./common";
 
+// Safely embed a ref value (integer or UUID string) in raw SQL
+const sqlRef = (ref) => `'${String(ref).replace(/'/g, "''")}'`;
+
 const setUploadStarted = async (started, time) => {
   const state = saltcorn.data.state.getState();
   const oldSession = await state.getConfig("last_offline_session");
@@ -35,7 +38,7 @@ const prepare = async () => {
   const { synchedTables } = state.mobileConfig;
   const syncInfos = {};
   for (const tblName of synchedTables) {
-    const syncInfo = { maxLoadedId: 0 };
+    const syncInfo = { lastModifiedAt: 0, lastRef: "" };
     const maxLm = await maxLastModified(tblName);
     if (maxLm) syncInfo.syncFrom = maxLm.valueOf();
     syncInfos[tblName] = syncInfo;
@@ -59,20 +62,20 @@ const insertRemoteData = async (table, rows, syncTimestamp) => {
     const infos = await saltcorn.data.db.select(
       `${saltcorn.data.db.sqlsanitize(tblName)}_sync_info`,
       {
-        ref: rest[pkName],
+        ref: String(rest[pkName]),
       }
     );
     if (infos.length > 0) {
       await saltcorn.data.db.query(
         `update "${saltcorn.data.db.sqlsanitize(tblName)}_sync_info"
                set last_modified=${last_modified}, deleted=false, modified_local = false
-               where ref=${rest[pkName]}`
+               where ref=${sqlRef(rest[pkName])}`
       );
     } else {
       await saltcorn.data.db.insert(
         `${saltcorn.data.db.sqlsanitize(tblName)}_sync_info`,
         {
-          ref,
+          ref: String(ref),
           last_modified: syncTimestamp,
           deleted: false,
           modified_local: false,
@@ -103,14 +106,15 @@ const syncRemoteData = async (syncInfos, syncTimestamp) => {
         loadUntil: syncTimestamp,
       },
     });
-    for (const [tblName, { rows, maxLoadedId }] of Object.entries(
+    for (const [tblName, { rows, maxModifiedAt, maxRef }] of Object.entries(
       loadResp.data
     )) {
       if (rows?.length > 0) {
         const table = getTable(tblName);
         hasMoreData = true;
         await insertRemoteData(table, rows, syncTimestamp);
-        syncInfos[tblName].maxLoadedId = maxLoadedId;
+        syncInfos[tblName].lastModifiedAt = maxModifiedAt ?? 0;
+        syncInfos[tblName].lastRef = maxRef ?? "";
       }
     }
   }
@@ -123,7 +127,7 @@ const prepDeletes = async (table, deletes) => {
   // don't delete if it's local modifed or unsynched
   const tblConflicts = await saltcorn.data.db.query(
     `select ref from "${saltcorn.data.db.sqlsanitize(tblName)}_sync_info"
-       where ref in (${deletes.map(({ ref }) => ref).join(",")}) and 
+       where ref in (${deletes.map(({ ref }) => sqlRef(ref)).join(",")}) and
          (last_modified is null or modified_local = true)`
   );
   if (tblConflicts.rows.length > 0) {
@@ -132,7 +136,7 @@ const prepDeletes = async (table, deletes) => {
     await saltcorn.data.db.query(
       `update "${saltcorn.data.db.sqlsanitize(tblName)}_sync_info"
          set last_modified = null, modified_local = true
-         where ref in (${conflicts.join(",")})`
+         where ref in (${conflicts.map(sqlRef).join(",")})`
     );
     const conflictsSet = new Set(conflicts);
     result = result.filter((del) => !conflictsSet.has(del.ref));
@@ -153,10 +157,12 @@ const prepDeletes = async (table, deletes) => {
         )}" as data_tbl join "${saltcorn.data.db.sqlsanitize(
           srcTbl.name
         )}_sync_info" as info_tbl
-         on data_tbl."${saltcorn.data.db.sqlsanitize(pkName)}" = info_tbl.ref
+         on CAST(info_tbl.ref AS TEXT) = CAST(data_tbl."${saltcorn.data.db.sqlsanitize(
+           pkName
+         )}" AS TEXT)
          where data_tbl."${saltcorn.data.db.sqlsanitize(
            field.name
-         )}" in (${result.map(({ ref }) => ref).join(",")}) 
+         )}" in (${result.map(({ ref }) => sqlRef(ref)).join(",")})
            and (info_tbl.last_modified is null or info_tbl.modified_local = true)`
       );
       if (fkConflicts.rows.length > 0) {
@@ -164,12 +170,12 @@ const prepDeletes = async (table, deletes) => {
         const conflicts = fkConflicts.rows.map(
           (conflict) => conflict[field.name]
         );
-        const conflictsSet = new Set(conflicts);
-        result = result.filter((del) => !conflictsSet.has(del.ref));
+        const conflictsSet = new Set(conflicts.map(String));
+        result = result.filter((del) => !conflictsSet.has(String(del.ref)));
         await saltcorn.data.db.query(
           `update "${saltcorn.data.db.sqlsanitize(tblName)}_sync_info"
            set last_modified = null, modified_local = true
-           where ref in (${conflicts.join(",")})`
+           where ref in (${conflicts.map(sqlRef).join(",")})`
         );
       }
     }
@@ -184,16 +190,16 @@ const applyDeletes = async (allDeletes, syncTimestamp) => {
       const pkName = table.pk_name;
       const safeDeletes = await prepDeletes(table, deletes);
       if (safeDeletes.length > 0) {
-        const delIds = safeDeletes.map(({ ref }) => ref).join(",");
+        const delRefs = safeDeletes.map(({ ref }) => sqlRef(ref)).join(",");
         await saltcorn.data.db.query(
           `delete from "${saltcorn.data.db.sqlsanitize(
             tblName
-          )}" where "${saltcorn.data.db.sqlsanitize(pkName)}" in (${delIds})`
+          )}" where "${saltcorn.data.db.sqlsanitize(pkName)}" in (${delRefs})`
         );
         await saltcorn.data.db.query(
           `update "${saltcorn.data.db.sqlsanitize(tblName)}_sync_info"
              set deleted = true, last_modified = ${syncTimestamp}, modified_local = false
-             where ref in (${delIds}) and deleted = false`
+             where ref in (${delRefs}) and deleted = false`
         );
       }
     }
@@ -226,9 +232,11 @@ const loadOfflineChanges = async (synchedTbls) => {
          from "${saltcorn.data.db.sqlsanitize(
            synchedTbl
          )}_sync_info" as info_tbl left join "${saltcorn.data.db.sqlsanitize(
-           synchedTbl
-         )}" as data_tbl
-         on info_tbl.ref = data_tbl."${saltcorn.data.db.sqlsanitize(pkName)}"
+        synchedTbl
+      )}" as data_tbl
+         on CAST(info_tbl.ref AS TEXT) = CAST(data_tbl."${saltcorn.data.db.sqlsanitize(
+           pkName
+         )}" AS TEXT)
          where info_tbl.modified_local = true`
     );
     const inserts = [];
@@ -280,8 +288,8 @@ const handleTranslatedIds = async (allUniqueConflicts, allTranslations) => {
         await saltcorn.data.db.update(tblName, { [table.pk_name]: to }, from);
         await saltcorn.data.db.query(
           `update "${saltcorn.data.db.sqlsanitize(tblName)}_sync_info"
-            set ref = ${to}
-            where ref = ${from} and deleted = false`
+            set ref = ${sqlRef(to)}
+            where ref = ${sqlRef(from)} and deleted = false`
         );
       }
       for (const fk of fks) {
@@ -311,7 +319,7 @@ const handleUniqueConflicts = async (uniqueConflicts, translatedIds) => {
         if (to === conflict[pkName]) {
           await table.deleteRows({ [pkName]: from });
           await saltcorn.data.db.deleteWhere(`${table.name}_sync_info`, {
-            ref: from,
+            ref: String(from),
           });
         }
       }
@@ -376,11 +384,11 @@ const updateSyncInfos = async (
       )
     );
     const values = refIds.map(
-      (ref) => `(${ref}, ${syncTimestamp}, ${deleted}, false)`
+      (ref) => `(${sqlRef(ref)}, ${syncTimestamp}, ${deleted}, false)`
     );
     await saltcorn.data.db.query(
       `delete from "${saltcorn.data.db.sqlsanitize(tblName)}_sync_info"
-         where ref in (${refIds.join(",")})`
+         where ref in (${refIds.map(sqlRef).join(",")})`
     );
     await saltcorn.data.db.query(
       `insert into "${saltcorn.data.db.sqlsanitize(tblName)}_sync_info"
@@ -714,7 +722,9 @@ export async function hasOfflineRows() {
              tblName
            )}_sync_info" as info_tbl 
            join "${saltcorn.data.db.sqlsanitize(tblName)}" as data_tbl
-           on info_tbl.ref = data_tbl."${saltcorn.data.db.sqlsanitize(pkName)}"
+           on CAST(info_tbl.ref AS TEXT) = CAST(data_tbl."${saltcorn.data.db.sqlsanitize(
+             pkName
+           )}" AS TEXT)
            where info_tbl.modified_local = true`
     );
     if (rows?.length > 0 && parseInt(rows[0].total) > 0) return true;

package/src/init.js

@@ -11,7 +11,6 @@ import {
   createSyncInfoTables,
   dbUpdateNeeded,
   updateDb,
-  getTableIds,
   createJwtTable,
 } from "./helpers/db_schema.js";
 import { publicLogin, checkJWT } from "./helpers/auth.js";
@@ -438,9 +437,6 @@ export async function init(mobileConfig) {
     await state.refresh_triggers();
     await state.refresh_config();
     await state.refresh_codepages();
-    state.mobileConfig.localTableIds = await getTableIds(
-      mobileConfig.localUserTables
-    );
     await state.setConfig("base_url", mobileConfig.server_path);
     await initI18Next();
     state.mobileConfig.encodedSiteLogo = await readSiteLogo();

package/src/routing/routes/api.js

@@ -14,10 +14,7 @@ export const loadTableRows = async (context) => {
   const mobileConfig = saltcorn.data.state.getState().mobileConfig;
   const table = saltcorn.data.models.Table.findOne({ name: tableName });
   if (!table) throw new Error(`The table '${tableName}' does not exist.`);
-  if (
-    mobileConfig.isOfflineMode ||
-    mobileConfig.localTableIds.indexOf(table.id) >= 0
-  ) {
+  if (mobileConfig.isOfflineMode) {
     const rows = await table.getRows(query, {
       orderBy: table.pk_name,
       forUser: mobileConfig.user,
@@ -38,10 +35,7 @@ export const updateTableRow = async (context) => {
   const mobileConfig = saltcorn.data.state.getState().mobileConfig;
   const table = saltcorn.data.models.Table.findOne({ name: tableName });
   if (!table) throw new Error(`The table '${tableName}' does not exist.`);
-  if (
-    mobileConfig.isOfflineMode ||
-    mobileConfig.localTableIds.indexOf(table.id) >= 0
-  ) {
+  if (mobileConfig.isOfflineMode) {
     const row = {};
     for (const [k, v] of new URLSearchParams(context.query).entries()) {
       row[k] = v;
@@ -73,10 +67,7 @@ export const insertTableRow = async (context) => {
   const table = saltcorn.data.models.Table.findOne({ name: tableName });
   const mobileConfig = saltcorn.data.state.getState().mobileConfig;
   if (!table) throw new Error(`The table '${tableName}' does not exist.`);
-  if (
-    mobileConfig.isOfflineMode ||
-    mobileConfig.localTableIds.indexOf(table.id) >= 0
-  ) {
+  if (mobileConfig.isOfflineMode) {
     const row = {};
     for (const [k, v] of new URLSearchParams(context.query).entries()) {
       row[k] = v;

package/src/routing/routes/delete.js

@@ -7,19 +7,29 @@ import i18next from "i18next";
 export const deleteRows = async (context) => {
   const { tableName, id } = context.params;
   const table = await saltcorn.data.models.Table.findOne({ name: tableName });
-  const { isOfflineMode, localTableIds, user } =
-    saltcorn.data.state.getState().mobileConfig;
-  if (isOfflineMode || localTableIds.indexOf(table.id) >= 0) {
-    if (user.role_id <= table.min_role_write) {
-      await table.deleteRows({ id });
-      // TODO 'table.is_owner' check?
-    } else
+  const { isOfflineMode, user } = saltcorn.data.state.getState().mobileConfig;
+  if (isOfflineMode) {
+    const role = user?.role_id || 100;
+    const where = { [table.pk_name]: id };
+    if (role <= table.min_role_write) {
+      await table.deleteRows(where, user);
+    } else if ((table.ownership_field_id || table.ownership_formula) && user) {
+      const row = await table.getJoinedRow({
+        where,
+        forUser: user,
+        forPublic: !user,
+      });
+      if (row && table.is_owner(user, row)) {
+        await table.deleteRows(where, user);
+      } else {
+        throw new saltcorn.data.utils.NotAuthorized(
+          i18next.t("Not authorized")
+        );
+      }
+    } else {
       throw new saltcorn.data.utils.NotAuthorized(i18next.t("Not authorized"));
-    if (isOfflineMode && (await hasOfflineRows()))
-      await setHasOfflineData(true);
-    // if (isOfflineMode && !(await offlineHelper.hasOfflineRows())) {
-    //   await offlineHelper.setOfflineSession(null);
-    // }
+    }
+    if (await hasOfflineRows()) await setHasOfflineData(true);
   } else {
     await apiCall({ method: "POST", path: `/delete/${tableName}/${id}` });
   }

package/src/routing/routes/edit.js

@@ -8,8 +8,8 @@ export const postToggleField = async (context) => {
   const { name, id, field_name } = context.params;
   const table = await saltcorn.data.models.Table.findOne({ name });
   const state = saltcorn.data.state.getState();
-  const { isOfflineMode, localTableIds, user } = state.mobileConfig;
-  if (isOfflineMode || localTableIds.indexOf(table.id) >= 0) {
+  const { isOfflineMode, user } = state.mobileConfig;
+  if (isOfflineMode) {
     if (user.role_id > table.min_role_write)
       throw new saltcorn.data.utils.NotAuthorized(i18next.t("Not authorized"));
     await table.toggleBool(+id, field_name, user);

package/src/routing/routes/fields.js

@@ -10,10 +10,7 @@ export const postShowCalculated = async (context) => {
   const mobileConfig = saltcorn.data.state.getState().mobileConfig;
   const table = saltcorn.data.models.Table.findOne({ name: tableName });
   if (!table) throw new Error(`The table '${tableName}' does not exist.`);
-  if (
-    mobileConfig.isOfflineMode ||
-    mobileConfig.localTableIds.indexOf(table.id) >= 0
-  ) {
+  if (mobileConfig.isOfflineMode) {
     const req = new MobileRequest({
       query: context.query ? parseQuery(context.query) : {},
       body: context.data || {},

package/www/js/iframe_view_utils.js

@@ -783,10 +783,7 @@ async function view_post(viewnameOrElem, route, data, onDone, sendState) {
     showLoadSpinner();
     let respData = undefined;
     const query = sendState ? buildQuery() : "";
-    if (
-      mobileConfig.isOfflineMode ||
-      (view?.table_id && mobileConfig.localTableIds.indexOf(view.table_id) >= 0)
-    ) {
+    if (mobileConfig.isOfflineMode) {
       respData = await parent.saltcorn.mobileApp.navigation.router.resolve({
         pathname: `post/view/${viewname}/${route}`,
         data,