tinybase 5.2.0-beta.3 → 5.2.0-beta.5

package/cjs/persisters/persister-electric-sql/with-schemas/index.cjs

@@ -48,13 +48,13 @@ const DATA_VERSION = 'data_version';
 const SCHEMA_VERSION = 'schema_version';
 const FROM = 'FROM ';
 const PRAGMA_TABLE = 'pragma_table_';
-const getWrappedCommand = (rawCmd, onSqlCommand) =>
+const getWrappedCommand = (executeCommand, onSqlCommand) =>
   onSqlCommand
-    ? async (sql, args) => {
-        onSqlCommand(sql, args);
-        return await rawCmd(sql, args);
+    ? async (sql, params) => {
+        onSqlCommand(sql, params);
+        return await executeCommand(sql, params);
       }
-    : rawCmd;
+    : executeCommand;
 const escapeId = (str) => `"${str.replace(/"/g, '""')}"`;
 const getPlaceholders = (array) =>
   arrayJoin(
@@ -92,14 +92,18 @@ const objDel = (obj, id) => {
 };
 const objToArray = (obj, cb) =>
   arrayMap(objEntries(obj), ([id, value]) => cb(value, id));
+const objMap = (obj, cb) =>
+  objNew(objToArray(obj, (value, id) => [id, cb(value, id)]));
 const objValues = (obj) => object.values(obj);
 const objSize = (obj) => size(objIds(obj));
 const objIsEmpty = (obj) => isObject(obj) && objSize(obj) == 0;
 
+const jsonString = JSON.stringify;
+const jsonParse = JSON.parse;
 const jsonStringWithUndefined = (obj) =>
-  JSON.stringify(obj, (_key, value) => (value === void 0 ? UNDEFINED : value));
+  jsonString(obj, (_key, value) => (value === void 0 ? UNDEFINED : value));
 const jsonParseWithUndefined = (str) =>
-  JSON.parse(str, (_key, value) => (value === UNDEFINED ? void 0 : value));
+  jsonParse(str, (_key, value) => (value === UNDEFINED ? void 0 : value));
 
 const mapNew = (entries) => new Map(entries);
 const mapGet = (map, key) => map?.get(key);
@@ -313,19 +317,23 @@ const setNew = (entryOrEntries) =>
 const setAdd = (set, value) => set?.add(value);
 
 const getCommandFunctions = (
-  cmd,
+  databaseExecuteCommand,
   managedTableNames,
   querySchema,
   onIgnoredError,
-  useOnConflict,
+  columnType,
+  orReplace,
+  encode,
+  decode,
 ) => {
   const schemaMap = mapNew();
   const canSelect = (tableName, rowIdColumnName) =>
     collHas(mapGet(schemaMap, tableName), rowIdColumnName);
   const refreshSchema = async () => {
     collClear(schemaMap);
-    arrayMap(await querySchema(cmd, managedTableNames), ({tn, cn}) =>
-      setAdd(mapEnsure(schemaMap, tn, setNew), cn),
+    arrayMap(
+      await querySchema(databaseExecuteCommand, managedTableNames),
+      ({tn, cn}) => setAdd(mapEnsure(schemaMap, tn, setNew), cn),
     );
   };
   const loadTable = async (tableName, rowIdColumnName) =>
@@ -333,10 +341,14 @@ const getCommandFunctions = (
       ? objNew(
           arrayFilter(
             arrayMap(
-              await cmd(SELECT_STAR_FROM + escapeId(tableName)),
+              await databaseExecuteCommand(
+                SELECT_STAR_FROM + escapeId(tableName),
+              ),
               (row) => [
                 row[rowIdColumnName],
-                objDel({...row}, rowIdColumnName),
+                decode
+                  ? objMap(objDel(row, rowIdColumnName), decode)
+                  : objDel(row, rowIdColumnName),
               ],
             ),
             ([rowId, row]) => !isUndefined(rowId) && !objIsEmpty(row),
@@ -364,7 +376,7 @@ const getCommandFunctions = (
       arrayIsEmpty(tableColumnNames) &&
       collHas(schemaMap, tableName)
     ) {
-      await cmd('DROP ' + TABLE + escapeId(tableName));
+      await databaseExecuteCommand('DROP ' + TABLE + escapeId(tableName));
       mapSet(schemaMap, tableName);
       return;
     }
@@ -372,14 +384,14 @@ const getCommandFunctions = (
     const currentColumnNames = setNew(collValues(tableSchemaColumns));
     if (!arrayIsEmpty(tableColumnNames)) {
       if (!collHas(schemaMap, tableName)) {
-        await cmd(
+        await databaseExecuteCommand(
           'CREATE ' +
             TABLE +
             escapeId(tableName) +
-            `(${escapeId(rowIdColumnName)}text PRIMARY KEY${arrayJoin(
+            `(${escapeId(rowIdColumnName)}${columnType} PRIMARY KEY${arrayJoin(
               arrayMap(
                 tableColumnNames,
-                (columnName) => COMMA + escapeId(columnName) + 'json',
+                (columnName) => COMMA + escapeId(columnName) + columnType,
               ),
             )});`,
         );
@@ -394,15 +406,15 @@ const getCommandFunctions = (
             [rowIdColumnName, ...tableColumnNames],
             async (columnName, index) => {
               if (!collDel(currentColumnNames, columnName)) {
-                await cmd(
+                await databaseExecuteCommand(
                   ALTER_TABLE +
                     escapeId(tableName) +
                     'ADD' +
                     escapeId(columnName) +
-                    (index == 0 ? 'text' : 'json'),
+                    columnType,
                 );
                 if (index == 0) {
-                  await cmd(
+                  await databaseExecuteCommand(
                     'CREATE UNIQUE INDEX pk ON ' +
                       escapeId(tableName) +
                       `(${escapeId(rowIdColumnName)})`,
@@ -419,7 +431,7 @@ const getCommandFunctions = (
       ...(!partial && deleteEmptyColumns
         ? arrayMap(collValues(currentColumnNames), async (columnName) => {
             if (columnName != rowIdColumnName) {
-              await cmd(
+              await databaseExecuteCommand(
                 ALTER_TABLE +
                   escapeId(tableName) +
                   'DROP' +
@@ -432,12 +444,14 @@ const getCommandFunctions = (
     ]);
     if (partial) {
       if (isUndefined(content)) {
-        await cmd(DELETE_FROM + escapeId(tableName) + WHERE + ' true');
+        await databaseExecuteCommand(
+          DELETE_FROM + escapeId(tableName) + WHERE + ' true',
+        );
       } else {
         await promiseAll(
           objToArray(content, async (row, rowId) => {
             if (isUndefined(row)) {
-              await cmd(
+              await databaseExecuteCommand(
                 DELETE_FROM +
                   escapeId(tableName) +
                   WHERE +
@@ -447,12 +461,17 @@ const getCommandFunctions = (
               );
             } else if (!arrayIsEmpty(tableColumnNames)) {
               await upsert(
-                cmd,
+                databaseExecuteCommand,
                 tableName,
                 rowIdColumnName,
                 objIds(row),
-                [rowId, ...objValues(row)],
-                useOnConflict,
+                [
+                  rowId,
+                  ...(encode
+                    ? arrayMap(objValues(row), encode)
+                    : objValues(row)),
+                ],
+                orReplace,
               );
             }
           }),
@@ -464,25 +483,27 @@ const getCommandFunctions = (
           collValues(mapGet(schemaMap, tableName)),
           (columnName) => columnName != rowIdColumnName,
         );
-        const args = [];
+        const params = [];
         const deleteRowIds = [];
         objToArray(content ?? {}, (row, rowId) => {
           arrayPush(
-            args,
+            params,
             rowId,
-            ...arrayMap(changingColumnNames, (cellId) => row?.[cellId]),
+            ...arrayMap(changingColumnNames, (cellId) =>
+              encode ? encode(row?.[cellId]) : row?.[cellId],
+            ),
           );
           arrayPush(deleteRowIds, rowId);
         });
         await upsert(
-          cmd,
+          databaseExecuteCommand,
           tableName,
           rowIdColumnName,
           changingColumnNames,
-          args,
-          useOnConflict,
+          params,
+          orReplace,
         );
-        await cmd(
+        await databaseExecuteCommand(
           DELETE_FROM +
             escapeId(tableName) +
             WHERE +
@@ -491,34 +512,36 @@ const getCommandFunctions = (
           deleteRowIds,
         );
       } else if (collHas(schemaMap, tableName)) {
-        await cmd(DELETE_FROM + escapeId(tableName) + WHERE + ' true');
+        await databaseExecuteCommand(
+          DELETE_FROM + escapeId(tableName) + WHERE + ' true',
+        );
       }
     }
   };
   const transaction = async (actions) => {
     let result;
-    await cmd('BEGIN');
+    await databaseExecuteCommand('BEGIN');
     try {
       result = await actions();
     } catch (error) {
       onIgnoredError?.(error);
     }
-    await cmd('END');
+    await databaseExecuteCommand('END');
     return result;
   };
   return [refreshSchema, loadTable, saveTable, transaction];
 };
 const upsert = async (
-  cmd,
+  executeCommand,
   tableName,
   rowIdColumnName,
   changingColumnNames,
-  args,
-  useOnConflict = true,
+  params,
+  orReplace = 0,
 ) =>
-  await cmd(
+  await executeCommand(
     'INSERT ' +
-      (useOnConflict ? EMPTY_STRING : 'OR REPLACE ') +
+      (orReplace ? 'OR REPLACE ' : EMPTY_STRING) +
       'INTO' +
       escapeId(tableName) +
       '(' +
@@ -530,9 +553,10 @@ const upsert = async (
         ),
       ) +
       ')VALUES' +
-      getUpsertPlaceholders(args, size(changingColumnNames) + 1) +
-      (useOnConflict
-        ? 'ON CONFLICT(' +
+      getUpsertPlaceholders(params, size(changingColumnNames) + 1) +
+      (orReplace
+        ? EMPTY_STRING
+        : 'ON CONFLICT(' +
           escapeId(rowIdColumnName) +
           ')DO UPDATE SET' +
           arrayJoin(
@@ -542,9 +566,8 @@ const upsert = async (
                 escapeId(columnName) + '=excluded.' + escapeId(columnName),
             ),
             COMMA,
-          )
-        : EMPTY_STRING),
-    arrayMap(args, (arg) => arg ?? null),
+          )),
+    arrayMap(params, (param) => param ?? null),
   );
 const getUpsertPlaceholders = (array, columnCount) =>
   arrayJoin(
@@ -566,7 +589,7 @@ const getUpsertPlaceholders = (array, columnCount) =>
 
 const createJsonPersister = (
   store,
-  cmd,
+  executeCommand,
   addPersisterListener,
   delPersisterListener,
   onIgnoredError,
@@ -577,15 +600,17 @@ const createJsonPersister = (
   querySchema,
   thing,
   getThing,
-  useOnConflict,
+  columnType,
+  orReplace,
 ) => {
   const [refreshSchema, loadTable, saveTable, transaction] =
     getCommandFunctions(
-      cmd,
+      executeCommand,
       managedTableNames,
       querySchema,
       onIgnoredError,
-      useOnConflict,
+      columnType,
+      orReplace,
     );
   const getPersisted = async () =>
     await transaction(async () => {
@@ -632,7 +657,7 @@ const createJsonPersister = (
 
 const createTabularPersister = (
   store,
-  cmd,
+  executeCommand,
   addPersisterListener,
   delPersisterListener,
   onIgnoredError,
@@ -647,15 +672,21 @@ const createTabularPersister = (
   querySchema,
   thing,
   getThing,
-  useOnConflict,
+  columnType,
+  orReplace,
+  encode,
+  decode,
 ) => {
   const [refreshSchema, loadTable, saveTable, transaction] =
     getCommandFunctions(
-      cmd,
+      executeCommand,
       managedTableNames,
       querySchema,
       onIgnoredError,
-      useOnConflict,
+      columnType,
+      orReplace,
+      encode,
+      decode,
     );
   const saveTables = async (tables, partial) =>
     await promiseAll(
@@ -854,23 +885,24 @@ const getConfigStructures = (configOrStoreTableName) => {
   return [0, autoLoadIntervalSeconds, tabularConfig, managedTableNames];
 };
 
-const createSqlitePersister = (
+const createCustomSqlitePersister = (
   store,
   configOrStoreTableName,
-  rawCmd,
-  addUpdateListener,
-  delUpdateListener,
+  rawExecuteCommand,
+  addChangeListener,
+  delChangeListener,
   onSqlCommand,
   onIgnoredError,
+  destroy,
   persist,
   thing,
   getThing = 'getDb',
-  useOnConflict,
+  orReplace,
 ) => {
   let dataVersion;
   let schemaVersion;
   let totalChanges;
-  const cmd = getWrappedCommand(rawCmd, onSqlCommand);
+  const executeCommand = getWrappedCommand(rawExecuteCommand, onSqlCommand);
   const [
     isJson,
     autoLoadIntervalSeconds,
@@ -882,7 +914,7 @@ const createSqlitePersister = (
     const startPolling = () =>
       (interval = startInterval(async () => {
         try {
-          const [{d, s, c}] = await cmd(
+          const [{d, s, c}] = await executeCommand(
             // eslint-disable-next-line max-len
             `${SELECT} ${DATA_VERSION} d,${SCHEMA_VERSION} s,TOTAL_CHANGES() c FROM ${PRAGMA}${DATA_VERSION} JOIN ${PRAGMA}${SCHEMA_VERSION}`,
           );
@@ -900,7 +932,7 @@ const createSqlitePersister = (
       dataVersion = schemaVersion = totalChanges = null;
       stopInterval(interval);
     };
-    const listeningHandle = addUpdateListener((tableName) => {
+    const listeningHandle = addChangeListener((tableName) => {
       if (managedTableNamesSet.has(tableName)) {
         stopPolling();
         listener();
@@ -910,30 +942,34 @@ const createSqlitePersister = (
     startPolling();
     return () => {
       stopPolling();
-      delUpdateListener(listeningHandle);
+      delChangeListener(listeningHandle);
     };
   };
   const delPersisterListener = (stopPollingAndDelUpdateListener) =>
     stopPollingAndDelUpdateListener();
   return (isJson ? createJsonPersister : createTabularPersister)(
     store,
-    cmd,
+    executeCommand,
     addPersisterListener,
     delPersisterListener,
     onIgnoredError,
-    () => 0,
+    destroy,
     persist,
     defaultedConfig,
     collValues(managedTableNamesSet),
-    async (cmd2, managedTableNames) =>
-      await cmd2(
+    async (executeCommand2, managedTableNames) =>
+      await executeCommand2(
         // eslint-disable-next-line max-len
         `${SELECT} t.name tn,c.name cn ${FROM}${PRAGMA_TABLE}list()t,${PRAGMA_TABLE}info(t.name)c ${WHERE} t.schema='main'AND t.type IN('table','view')AND t.name IN(${getPlaceholders(managedTableNames)})ORDER BY t.name,c.name`,
         managedTableNames,
       ),
     thing,
     getThing,
-    useOnConflict,
+    EMPTY_STRING,
+    orReplace,
+    (cellOrValue) =>
+      cellOrValue === true ? 1 : cellOrValue === false ? 0 : cellOrValue,
+    void 0,
   );
 };
 
@@ -944,7 +980,7 @@ const createElectricSqlPersister = (
   onSqlCommand,
   onIgnoredError,
 ) =>
-  createSqlitePersister(
+  createCustomSqlitePersister(
     store,
     configOrStoreTableName,
     async (sql, args = []) => await electricClient.db.raw({sql, args}),
@@ -958,6 +994,7 @@ const createElectricSqlPersister = (
     (unsubscribeFunction) => unsubscribeFunction(),
     onSqlCommand,
     onIgnoredError,
+    () => 0,
     1,
     // StoreOnly,
     electricClient,