tinybase 8.5.0 → 9.0.0-beta.0

package/persisters/persister-powersync/with-schemas/index.js

@@ -48,6 +48,7 @@ const tryCatch = async (action, then1, then2) => {
   }
 };
 
+const arrayHas = (array, value) => array.includes(value);
 const arrayForEach = (array, cb) => array.forEach(cb);
 const arrayJoin = (array, sep = EMPTY_STRING) => array.join(sep);
 const arrayMap = (array, cb) => array.map(cb);
@@ -57,14 +58,6 @@ const arrayClear = (array, to) => array.splice(0, to);
 const arrayPush = (array, ...values) => array.push(...values);
 const arrayShift = (array) => array.shift();
 
-const collSize = (coll) => coll?.size ?? 0;
-const collHas = (coll, keyOrValue) => coll?.has(keyOrValue) ?? false;
-const collIsEmpty = (coll) => isUndefined(coll) || collSize(coll) == 0;
-const collValues = (coll) => [...(coll?.values() ?? [])];
-const collClear = (coll) => coll.clear();
-const collForEach = (coll, cb) => coll?.forEach(cb);
-const collDel = (coll, keyOrValue) => coll?.delete(keyOrValue);
-
 const object = Object;
 const getPrototypeOf = (obj) => object.getPrototypeOf(obj);
 const objEntries = object.entries;
@@ -96,14 +89,6 @@ const objValues = (obj) => object.values(obj);
 const objSize = (obj) => size(objIds(obj));
 const objIsEmpty = (obj) => isObject(obj) && objSize(obj) == 0;
 
-const setNew = (entryOrEntries) =>
-  new Set(
-    isArray(entryOrEntries) || isUndefined(entryOrEntries)
-      ? entryOrEntries
-      : [entryOrEntries],
-  );
-const setAdd = (set, value) => set?.add(value);
-
 const SINGLE_ROW_ID = '_';
 const DEFAULT_ROW_ID_COLUMN_NAME = '_id';
 const SELECT = 'SELECT';
@@ -122,7 +107,6 @@ const SCHEMA_VERSION = 'schema_version';
 const PRAGMA_TABLE = 'pragma_table_';
 const CREATE = 'CREATE ';
 const CREATE_TABLE = CREATE + TABLE;
-const OR_REPLACE = 'OR REPLACE ';
 const TABLE_NAME_PLACEHOLDER = '$tableName';
 const getWrappedCommand = (executeCommand, onSqlCommand) =>
   onSqlCommand
@@ -147,6 +131,14 @@ const getWhereCondition = (tableName, condition = TRUE) =>
   WHERE +
   `(${strReplace(condition, TABLE_NAME_PLACEHOLDER, escapeId(tableName))})`;
 
+const collSize = (coll) => coll?.size ?? 0;
+const collHas = (coll, keyOrValue) => coll?.has(keyOrValue) ?? false;
+const collIsEmpty = (coll) => isUndefined(coll) || collSize(coll) == 0;
+const collValues = (coll) => [...(coll?.values() ?? [])];
+const collClear = (coll) => coll.clear();
+const collForEach = (coll, cb) => coll?.forEach(cb);
+const collDel = (coll, keyOrValue) => coll?.delete(keyOrValue);
+
 const map = Map;
 const mapNew = (entries) => new map(entries);
 const mapGet = (map2, key) => map2?.get(key);
@@ -186,6 +178,14 @@ const visitTree = (node, path, ensureLeaf, pruneLeaf, p = 0) =>
     },
   );
 
+const setNew = (entryOrEntries) =>
+  new Set(
+    isArray(entryOrEntries) || isUndefined(entryOrEntries)
+      ? entryOrEntries
+      : [entryOrEntries],
+  );
+const setAdd = (set, value) => set?.add(value);
+
 const COLUMN_NAME = 'ColumnName';
 const STORE = 'store';
 const JSON$1 = 'json';
@@ -208,6 +208,8 @@ const DEFAULT_TABULAR_VALUES_CONFIG = {
   save: 0,
   [TABLE_NAME]: TINYBASE + '_values',
 };
+const getValuesIn = (config) => (isArray(config) ? config : void 0);
+const hasValues = (config) => isTrue(config) || isArray(config);
 const getDefaultedConfig = (configOrStoreTableName) =>
   objMerge(
     DEFAULT_CONFIG,
@@ -258,11 +260,15 @@ const getConfigStructures = (configOrStoreTableName) => {
     ];
   }
   const {tables: {load = {}, save = {}} = {}, values = {}} = config;
-  const valuesConfig = slice(
-    objValues(objMerge(DEFAULT_TABULAR_VALUES_CONFIG, values)),
-    0,
-    objSize(DEFAULT_TABULAR_VALUES_CONFIG),
-  );
+  const valuesConfigObj = objMerge(DEFAULT_TABULAR_VALUES_CONFIG, values);
+  const {load: valuesLoad, save: valuesSave} = valuesConfigObj;
+  const valuesConfig = [
+    hasValues(valuesLoad),
+    hasValues(valuesSave),
+    valuesConfigObj[TABLE_NAME],
+    getValuesIn(valuesLoad),
+    getValuesIn(valuesSave),
+  ];
   const valuesTable = valuesConfig[2];
   const managedTableNames = setNew(valuesTable);
   const excludedTableNames = setNew(valuesTable);
@@ -671,8 +677,18 @@ const getCommandFunctions = (
       ({tn, cn}) => setAdd(mapEnsure(schemaMap, tn, setNew), cn),
     );
   };
-  const loadTable = async (tableName, rowIdColumnName, condition) =>
-    canSelect(tableName, rowIdColumnName)
+  const loadTable = async (
+    tableName,
+    rowIdColumnName,
+    condition,
+    contentSubIds,
+  ) => {
+    const contentSubIdSet = isUndefined(contentSubIds)
+      ? void 0
+      : setNew(contentSubIds);
+    const includeContentSubId = (contentSubId) =>
+      isUndefined(contentSubIdSet) || collHas(contentSubIdSet, contentSubId);
+    return canSelect(tableName, rowIdColumnName)
       ? objNew(
           arrayFilter(
             arrayMap(
@@ -681,17 +697,35 @@ const getCommandFunctions = (
                   escapeId(tableName) +
                   getWhereCondition(tableName, condition),
               ),
-              (row) => [
-                row[rowIdColumnName],
-                decode
+              (row) => {
+                const rowId = row[rowIdColumnName];
+                const rowContent = decode
                   ? objMap(objDel(row, rowIdColumnName), decode)
-                  : objDel(row, rowIdColumnName),
-              ],
+                  : objDel(row, rowIdColumnName);
+                return [
+                  rowId,
+                  isUndefined(contentSubIdSet)
+                    ? rowContent
+                    : objNew(
+                        arrayFilter(
+                          objToArray(
+                            rowContent,
+                            (cellOrValue, contentSubId) => [
+                              contentSubId,
+                              cellOrValue,
+                            ],
+                          ),
+                          ([contentSubId]) => includeContentSubId(contentSubId),
+                        ),
+                      ),
+                ];
+              },
             ),
             (entry) => !isUndefined(entry[0]) && !objIsEmpty(entry[1]),
           ),
         )
       : {};
+  };
   const saveTable = async (
     tableName,
     rowIdColumnName,
@@ -700,15 +734,23 @@ const getCommandFunctions = (
     deleteEmptyTable,
     partial = false,
     condition = TRUE,
+    contentSubIds,
   ) => {
+    const contentSubIdSet = isUndefined(contentSubIds)
+      ? void 0
+      : setNew(contentSubIds);
+    const includeContentSubId = (contentSubId) =>
+      isUndefined(contentSubIdSet) || collHas(contentSubIdSet, contentSubId);
     const settingColumnNameSet = setNew();
     objMap(content ?? {}, (contentRow) =>
-      arrayMap(objIds(contentRow ?? {}), (cellOrValueId) =>
-        setAdd(settingColumnNameSet, cellOrValueId),
+      arrayMap(
+        arrayFilter(objIds(contentRow ?? {}), includeContentSubId),
+        (cellOrValueId) => setAdd(settingColumnNameSet, cellOrValueId),
       ),
     );
     const settingColumnNames = collValues(settingColumnNameSet);
     if (
+      isUndefined(contentSubIdSet) &&
       !partial &&
       deleteEmptyTable &&
       condition == TRUE &&
@@ -720,7 +762,13 @@ const getCommandFunctions = (
       return;
     }
     const currentColumnNames = mapGet(schemaMap, tableName);
-    const unaccountedColumnNames = setNew(collValues(currentColumnNames));
+    const unaccountedColumnNames = setNew(
+      arrayFilter(
+        collValues(currentColumnNames),
+        (columnName) =>
+          columnName == rowIdColumnName || includeContentSubId(columnName),
+      ),
+    );
     if (!arrayIsEmpty(settingColumnNames)) {
       if (!collHas(schemaMap, tableName)) {
         await databaseExecuteCommand(
@@ -786,11 +834,13 @@ const getCommandFunctions = (
     ]);
     if (partial) {
       if (isUndefined(content)) {
-        await databaseExecuteCommand(
-          DELETE_FROM +
-            escapeId(tableName) +
-            getWhereCondition(tableName, condition),
-        );
+        if (isUndefined(contentSubIdSet)) {
+          await databaseExecuteCommand(
+            DELETE_FROM +
+              escapeId(tableName) +
+              getWhereCondition(tableName, condition),
+          );
+        }
       } else {
         await promiseAll(
           objToArray(content, async (row, rowId) => {
@@ -803,18 +853,24 @@ const getCommandFunctions = (
                 [rowId],
               );
             } else if (!arrayIsEmpty(settingColumnNames)) {
-              await upsert(
-                databaseExecuteCommand,
-                tableName,
-                rowIdColumnName,
+              const changingColumnNames = arrayFilter(
                 objIds(row),
-                {
-                  [rowId]: encode
-                    ? arrayMap(objValues(row), encode)
-                    : objValues(row),
-                },
-                currentColumnNames,
+                includeContentSubId,
               );
+              if (!arrayIsEmpty(changingColumnNames)) {
+                await upsert(
+                  databaseExecuteCommand,
+                  tableName,
+                  rowIdColumnName,
+                  changingColumnNames,
+                  {
+                    [rowId]: arrayMap(changingColumnNames, (cellId) =>
+                      encode ? encode(row[cellId]) : row[cellId],
+                    ),
+                  },
+                  currentColumnNames,
+                );
+              }
             }
           }),
         );
@@ -823,7 +879,9 @@ const getCommandFunctions = (
       if (!arrayIsEmpty(settingColumnNames)) {
         const changingColumnNames = arrayFilter(
           collValues(mapGet(schemaMap, tableName)),
-          (changingColumnName) => changingColumnName != rowIdColumnName,
+          (changingColumnName) =>
+            changingColumnName != rowIdColumnName &&
+            includeContentSubId(changingColumnName),
         );
         const rows = {};
         const deleteRowIds = [];
@@ -839,6 +897,7 @@ const getCommandFunctions = (
           rowIdColumnName,
           changingColumnNames,
           rows,
+          currentColumnNames,
         );
         await databaseExecuteCommand(
           DELETE_FROM +
@@ -847,7 +906,10 @@ const getCommandFunctions = (
             `AND${escapeId(rowIdColumnName)}NOT IN(${getPlaceholders(deleteRowIds)})`,
           deleteRowIds,
         );
-      } else if (collHas(schemaMap, tableName)) {
+      } else if (
+        isUndefined(contentSubIdSet) &&
+        collHas(schemaMap, tableName)
+      ) {
         await databaseExecuteCommand(
           DELETE_FROM +
             escapeId(tableName) +
@@ -986,7 +1048,13 @@ const createTabularPersister = (
   [
     tablesLoadConfig,
     tablesSaveConfig,
-    [valuesLoad, valuesSave, valuesTableName],
+    [
+      valuesLoad,
+      valuesSave,
+      valuesTableName,
+      valuesLoadValueIds,
+      valuesSaveValueIds,
+    ],
   ],
   managedTableNames,
   querySchema,
@@ -1036,15 +1104,33 @@ const createTabularPersister = (
         },
       ),
     );
+  const getValuesSubset = (values, valueIds, partial) =>
+    objNew(
+      partial == true
+        ? arrayFilter(
+            objToArray(values, (value, valueId) => [valueId, value]),
+            ([valueId]) => arrayHas(valueIds, valueId),
+          )
+        : arrayFilter(
+            arrayMap(valueIds, (valueId) => [valueId, values[valueId]]),
+            ([, value]) => !isUndefined(value),
+          ),
+    );
   const saveValues = async (values, partial) =>
     valuesSave
       ? await saveTable(
           valuesTableName,
           DEFAULT_ROW_ID_COLUMN_NAME,
-          {[SINGLE_ROW_ID]: values},
+          {
+            [SINGLE_ROW_ID]: isUndefined(valuesSaveValueIds)
+              ? values
+              : getValuesSubset(values, valuesSaveValueIds, partial),
+          },
           true,
           true,
           partial,
+          void 0,
+          valuesSaveValueIds,
         )
       : null;
   const loadTables = async () =>
@@ -1064,9 +1150,14 @@ const createTabularPersister = (
     );
   const loadValues = async () =>
     valuesLoad
-      ? (await loadTable(valuesTableName, DEFAULT_ROW_ID_COLUMN_NAME))[
-          SINGLE_ROW_ID
-        ]
+      ? (
+          await loadTable(
+            valuesTableName,
+            DEFAULT_ROW_ID_COLUMN_NAME,
+            void 0,
+            valuesLoadValueIds,
+          )
+        )[SINGLE_ROW_ID]
       : {};
   const getPersisted = () =>
     transaction(async () => {
@@ -1241,83 +1332,57 @@ const createPowerSyncPersister = (
     // StoreOnly,
     powerSync,
     'getPowerSync',
-    viewUpsert,
+    powerSyncUpdateThenInsert,
   );
 };
-const viewUpsert = async (
+const powerSyncUpdateThenInsert = async (
   executeCommand,
   tableName,
   rowIdColumnName,
   changingColumnNames,
   rows,
-  currentColumnNames,
 ) => {
-  const offset = [1];
-  const changingColumnNamesSet = setNew(changingColumnNames);
-  const unchangingColumnNames = currentColumnNames
-    ? arrayFilter(
-        [...currentColumnNames],
-        (currentColumnName) =>
-          currentColumnName != rowIdColumnName &&
-          !collHas(changingColumnNamesSet, currentColumnName),
-      )
-    : [];
-  if (!arrayIsEmpty(unchangingColumnNames)) {
-    const ids = objIds(rows);
-    const unchangingData = objNew(
-      arrayMap(
+  const assignments = arrayJoin(
+    arrayMap(
+      changingColumnNames,
+      (columnName, index) => escapeId(columnName) + '=$' + (index + 1),
+    ),
+    COMMA,
+  );
+  for (const [id, row] of objToArray(rows, (row2, id2) => [id2, row2])) {
+    const rowParams = arrayMap(row, (value) => value ?? null);
+    if (
+      arrayIsEmpty(
         await executeCommand(
-          SELECT +
-            escapeColumnNames(rowIdColumnName, ...unchangingColumnNames) +
-            FROM +
+          UPDATE +
             escapeId(tableName) +
+            ' SET' +
+            assignments +
+            ' ' +
             WHERE +
             escapeId(rowIdColumnName) +
-            'IN(' +
-            getPlaceholders(ids) +
-            ')',
-          ids,
-        ),
-        (unchangingRow) => [unchangingRow[rowIdColumnName], unchangingRow],
-      ),
-    );
-    arrayForEach(ids, (id) =>
-      arrayPush(
-        rows[id],
-        ...arrayMap(
-          unchangingColumnNames,
-          (unchangingColumnName) =>
-            unchangingData?.[id]?.[unchangingColumnName] ?? null,
+            '=$' +
+            (row.length + 1) +
+            ' RETURNING' +
+            escapeId(rowIdColumnName),
+          [...rowParams, id],
         ),
-      ),
-    );
+      )
+    ) {
+      const offset = [1];
+      await executeCommand(
+        INSERT +
+          ' INTO' +
+          escapeId(tableName) +
+          '(' +
+          escapeColumnNames(rowIdColumnName, ...changingColumnNames) +
+          ')VALUES(' +
+          getPlaceholders([id, ...row], offset) +
+          ')',
+        [id, ...rowParams],
+      );
+    }
   }
-  await executeCommand(
-    INSERT +
-      ' ' +
-      OR_REPLACE +
-      'INTO' +
-      escapeId(tableName) +
-      '(' +
-      escapeColumnNames(
-        rowIdColumnName,
-        ...changingColumnNames,
-        ...unchangingColumnNames,
-      ) +
-      ')VALUES' +
-      arrayJoin(
-        objToArray(
-          rows,
-          (row) =>
-            '($' + offset[0]++ + ',' + getPlaceholders(row, offset) + ')',
-        ),
-        COMMA,
-      ),
-    objToArray(rows, (row, id) => [
-      id,
-      ...arrayMap(row, (value) => value ?? null),
-    ]).flat(),
-  );
 };
 
 export {createPowerSyncPersister};