prepare new database abstraction layer

src/api/admin.ts

@@ -19,7 +19,7 @@ import { json } from 'body-parser'
 import { Router } from 'express'
 import { BadRequest, Conflict } from 'http-errors'
 import * as Sequelize from 'sequelize'
-import { Database } from '../database'
+import { SimpleDatabase } from '../database/simple'
 import { addPurchase, canDoNextPurchase } from '../function/purchase'
 import { getStatusMessage, setStatusMessage } from '../function/statusmessage'
 import { EventHandler } from '../monitoring/eventhandler'
@@ -28,7 +28,7 @@ import { verifyIdentitifyToken, TokenValidationException } from '../util/identit
 import { WebsocketApi } from '../websocket'
 
 export const createAdminRouter = ({ database, websocket, eventHandler }: {
-  database: Database
+  database: SimpleDatabase
   websocket: WebsocketApi
   eventHandler: EventHandler
 }) => {
@@ -60,7 +60,9 @@ export const createAdminRouter = ({ database, websocket, eventHandler }: {
 
   router.get('/status-message', async (_, res, next) => {
     try {
-      const currentStatusMessage = await getStatusMessage({ database })
+      const currentStatusMessage = await database.transaction(async (transaction) => {
+        return getStatusMessage({ transaction })
+      })
 
       res.json({
         statusMessage: currentStatusMessage
@@ -102,12 +104,12 @@ export const createAdminRouter = ({ database, websocket, eventHandler }: {
       }
 
       await database.transaction(async (transaction) => {
-        const userEntryUnsafe = await database.user.findOne({
+        const userEntryUnsafe = await transaction.legacy.database.user.findOne({
           where: {
             mail
           },
           attributes: ['familyId'],
-          transaction
+          transaction: transaction.legacy.transaction
         })
 
         if (!userEntryUnsafe) {
@@ -119,13 +121,12 @@ export const createAdminRouter = ({ database, websocket, eventHandler }: {
         }
 
         await addPurchase({
-          database,
+          transaction,
           familyId: userEntry.familyId,
           type,
           service: 'directpurchase',
           transactionId: 'legacyunlock-' + type + '-' + generatePurchaseId(),
-          websocket,
+          websocket
-          transaction
         })
       })
 
@@ -165,14 +166,14 @@ export const createAdminRouter = ({ database, websocket, eventHandler }: {
       }
 
       const response = await database.transaction(async (transaction) => {
-        const userValid = await database.user.count({
+        const userValid = await transaction.legacy.database.user.count({
           where: {
             familyId: tokenContent.familyId,
             userId: tokenContent.userId,
             mail: tokenContent.mail,
             type: 'parent'
           },
-          transaction
+          transaction: transaction.legacy.transaction
         })
 
         if (!userValid) return {
@@ -185,7 +186,7 @@ export const createAdminRouter = ({ database, websocket, eventHandler }: {
 
         if (tokenContent.mail !== '') mailToReturn = tokenContent.mail
         else {
-          const userEntryWithMail = await database.user.findOne({
+          const userEntryWithMail = await transaction.legacy.database.user.findOne({
             where: {
               familyId: tokenContent.familyId,
               mail: {
@@ -193,7 +194,7 @@ export const createAdminRouter = ({ database, websocket, eventHandler }: {
               },
               type: 'parent'
             },
-            transaction
+            transaction: transaction.legacy.transaction
           })
 
           if (!userEntryWithMail) return {
@@ -207,11 +208,12 @@ export const createAdminRouter = ({ database, websocket, eventHandler }: {
 
         let wasAlreadyExecuted: boolean
 
-        const oldPurchaseByPurchaseId = await database.purchase.findOne({
+        const oldPurchaseByPurchaseId = await transaction.legacy.database.purchase.findOne({
           where: {
             service: 'directpurchase',
             transactionId: purchaseId
-          }
+          },
+          transaction: transaction.legacy.transaction
         })
 
         if (oldPurchaseByPurchaseId === null) wasAlreadyExecuted = false
@@ -222,11 +224,11 @@ export const createAdminRouter = ({ database, websocket, eventHandler }: {
         }
 
         if (!wasAlreadyExecuted) {
-          const familyEntry = await database.family.findOne({
+          const familyEntry = await transaction.legacy.database.family.findOne({
             where: {
               familyId: tokenContent.familyId
             },
-            transaction
+            transaction: transaction.legacy.transaction
           })
 
           if (!familyEntry) return {
@@ -240,11 +242,11 @@ export const createAdminRouter = ({ database, websocket, eventHandler }: {
           })
 
           if (!canDoPurchase) {
-            const lastPurchase = await database.purchase.findOne({
+            const lastPurchase = await transaction.legacy.database.purchase.findOne({
               where: {
                 familyId: tokenContent.familyId
               },
-              transaction,
+              transaction: transaction.legacy.transaction,
               order: [['loggedAt', 'DESC']],
               limit: 1
             })
@@ -263,13 +265,12 @@ export const createAdminRouter = ({ database, websocket, eventHandler }: {
 
           if (!dryRun) {
             await addPurchase({
-              database,
+              transaction,
               familyId: tokenContent.familyId,
               type,
               service: 'directpurchase',
               transactionId: purchaseId,
               websocket,
-              transaction
             })
           }
         }

src/api/auth.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2021 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -18,7 +18,7 @@
 import { json } from 'body-parser'
 import { Router } from 'express'
 import { BadRequest } from 'http-errors'
-import { Database } from '../database'
+import { SimpleDatabase } from '../database/simple'
 import { sendLoginCode, signInByMailCode } from '../function/authentication/login-by-mail'
 import { isMailAddressCoveredByWhitelist, isMailServerBlacklisted, sanitizeMailAddress } from '../util/mail'
 import {
@@ -26,7 +26,7 @@ import {
   isSignInByMailCodeRequest
 } from './validator'
 
-export const createAuthRouter = (database: Database) => {
+export const createAuthRouter = (database: SimpleDatabase) => {
   const router = Router()
 
   router.post('/send-mail-login-code-v2', json(), async (req, res, next) => {

src/api/child.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -18,7 +18,7 @@
 import { json } from 'body-parser'
 import { Router } from 'express'
 import { BadRequest } from 'http-errors'
-import { Database } from '../database'
+import { SimpleDatabase } from '../database/simple'
 import { addChildDevice } from '../function/child/add-device'
 import { logoutAtPrimaryDevice } from '../function/child/logout-at-primary-device'
 import { setPrimaryDevice } from '../function/child/set-primary-device'
@@ -27,7 +27,7 @@ import { isRegisterChildDeviceRequest, isRequestWithAuthToken, isUpdatePrimaryDe
 import { EventHandler } from '../monitoring/eventhandler'
 
 export const createChildRouter = ({ database, websocket, eventHandler }: {
-  database: Database
+  database: SimpleDatabase
   websocket: WebsocketApi
   eventHandler: EventHandler
 }) => {

src/api/index.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -18,7 +18,7 @@
 import * as basicAuth from 'basic-auth'
 import * as express from 'express'
 import { VisibleConnectedDevicesManager } from '../connected-devices'
-import { Database } from '../database'
+import { SimpleDatabase } from '../database/simple'
 import { EventHandler } from '../monitoring/eventhandler'
 import { WebsocketApi } from '../websocket'
 import { createAdminRouter } from './admin'
@@ -31,7 +31,7 @@ import { createSyncRouter } from './sync'
 const adminToken = process.env.ADMIN_TOKEN || ''
 
 export const createApi = ({ database, websocket, connectedDevicesManager, eventHandler }: {
-  database: Database
+  database: SimpleDatabase
   websocket: WebsocketApi
   connectedDevicesManager: VisibleConnectedDevicesManager
   eventHandler: EventHandler

src/api/parent.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2023 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -20,7 +20,7 @@ import { createHmac } from 'crypto'
 import { Router } from 'express'
 import { BadRequest, Forbidden, Unauthorized } from 'http-errors'
 import { config } from '../config'
-import { Database, Transaction } from '../database'
+import { SimpleDatabase, SimpleDatabaseTransaction } from '../database/simple'
 import { deleteAccount } from '../function/cleanup/account-deletion'
 import { removeDevice } from '../function/device/remove-device'
 import { createAddDeviceToken } from '../function/parent/create-add-device-token'
@@ -44,7 +44,7 @@ import {
 export const createParentRouter = ({
   database, websocket, eventHandler
 }: {
-  database: Database
+  database: SimpleDatabase
   websocket: WebsocketApi
   eventHandler: EventHandler
 }) => {
@@ -58,7 +58,7 @@ export const createParentRouter = ({
 
       const { mailAuthToken } = req.body
       const { status, mail } = await database.transaction(async (transaction) => {
-        return getStatusByMailToken({ database, mailAuthToken, transaction })
+        return getStatusByMailToken({ transaction, mailAuthToken })
       })
 
       res.json({
@@ -153,13 +153,13 @@ export const createParentRouter = ({
     deviceAuthToken: string
     parentId: string
     secondPasswordHash: string
-    transaction: Transaction
+    transaction: SimpleDatabaseTransaction
   }) {
-    const deviceEntry = await database.device.findOne({
+    const deviceEntry = await transaction.legacy.database.device.findOne({
       where: {
         deviceAuthToken: deviceAuthToken
       },
-      transaction
+      transaction: transaction.legacy.transaction
     })
 
     if (!deviceEntry) {
@@ -171,13 +171,13 @@ export const createParentRouter = ({
         throw new Unauthorized()
       }
 
-      const parentEntry = await database.user.findOne({
+      const parentEntry = await transaction.legacy.database.user.findOne({
         where: {
           familyId: deviceEntry.familyId,
           type: 'parent',
           userId: deviceEntry.currentUserId
         },
-        transaction
+        transaction: transaction.legacy.transaction
       })
 
       if (!parentEntry) {
@@ -187,11 +187,11 @@ export const createParentRouter = ({
       return { deviceEntry, parentEntry }
     } else if (secondPasswordHash.startsWith('u2f:')) {
       try {
-        const familyEntryUnsafe = await database.family.findOne({
+        const familyEntryUnsafe = await transaction.legacy.database.family.findOne({
           where: {
             familyId: deviceEntry.familyId
           },
-          transaction,
+          transaction: transaction.legacy.transaction,
           attributes: ['hasFullVersion']
         })
 
@@ -208,7 +208,6 @@ export const createParentRouter = ({
           hasFullVersion,
           familyId: deviceEntry.familyId,
           deviceId: deviceEntry.deviceId,
-          database,
           transaction,
           calculateHmac: (secret) => createHmac('sha256', secret)
             .update('direct action')
@@ -217,13 +216,13 @@ export const createParentRouter = ({
 
         if (u2fResult.userId !== parentId) throw new Unauthorized()
 
-        const parentEntry = await database.user.findOne({
+        const parentEntry = await transaction.legacy.database.user.findOne({
           where: {
             familyId: deviceEntry.familyId,
             type: 'parent',
             userId: u2fResult.userId
           },
-          transaction
+          transaction: transaction.legacy.transaction
         })
 
         if (!parentEntry) {
@@ -236,14 +235,14 @@ export const createParentRouter = ({
         else throw ex
       }
     } else {
-      const parentEntry = await database.user.findOne({
+      const parentEntry = await transaction.legacy.database.user.findOne({
         where: {
           familyId: deviceEntry.familyId,
           type: 'parent',
           userId: parentId,
           secondPasswordHash: secondPasswordHash
         },
-        transaction
+        transaction: transaction.legacy.transaction
       })
 
       if (!parentEntry) {
@@ -268,7 +267,7 @@ export const createParentRouter = ({
           transaction
         })
 
-        return createAddDeviceToken({ familyId: deviceEntry.familyId, database, transaction })
+        return createAddDeviceToken({ familyId: deviceEntry.familyId, transaction })
       })
 
       res.json({ token, deviceId })
@@ -313,11 +312,10 @@ export const createParentRouter = ({
         })
 
         await removeDevice({
-          database,
+          transaction,
           familyId: deviceEntry.familyId,
           deviceId: req.body.deviceId,
-          websocket,
+          websocket
-          transaction
         })
       })
 

src/api/purchase.ts

@@ -18,7 +18,7 @@
 import { json } from 'body-parser'
 import { Router } from 'express'
 import { BadRequest, Conflict, Unauthorized } from 'http-errors'
-import { Database } from '../database'
+import { SimpleDatabase } from '../database/simple'
 import {
   addPurchase,
   areGooglePlayPaymentsPossible,
@@ -31,7 +31,7 @@ import { WebsocketApi } from '../websocket'
 import { isCanDoPurchaseRequest, isFinishPurchaseByGooglePlayRequest } from './validator'
 
 export const createPurchaseRouter = ({ database, websocket }: {
-  database: Database
+  database: SimpleDatabase
   websocket: WebsocketApi
 }) => {
   const router = Router()
@@ -49,9 +49,8 @@ export const createPurchaseRouter = ({ database, websocket }: {
 
       const result: boolean = await database.transaction(async (transaction) => {
         const familyEntry = await requireFamilyEntry({
-          database,
+          transaction,
           deviceAuthToken: req.body.deviceAuthToken,
-          transaction
         })
 
         return canDoNextPurchase({
@@ -76,12 +75,12 @@ export const createPurchaseRouter = ({ database, websocket }: {
       }
 
       await database.transaction(async (transaction) => {
-        const deviceEntryUnsafe = await database.device.findOne({
+        const deviceEntryUnsafe = await transaction.legacy.database.device.findOne({
           where: {
             deviceAuthToken: req.body.deviceAuthToken
           },
           attributes: ['familyId'],
-          transaction
+          transaction: transaction.legacy.transaction
         })
 
         if (!deviceEntryUnsafe) {
@@ -122,13 +121,12 @@ export const createPurchaseRouter = ({ database, websocket }: {
         }
 
         await addPurchase({
-          database,
+          transaction,
           familyId: deviceEntry.familyId,
           type,
           service: 'googleplay',
           transactionId: orderId,
-          websocket,
+          websocket
-          transaction
         })
       })
 

src/api/sync.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -19,7 +19,7 @@ import { json } from 'body-parser'
 import { Router } from 'express'
 import { BadRequest, Unauthorized } from 'http-errors'
 import { VisibleConnectedDevicesManager } from '../connected-devices'
-import { Database } from '../database'
+import { SimpleDatabase } from '../database/simple'
 import { reportDeviceRemoved } from '../function/device/report-device-removed'
 import { applyActionsFromDevice } from '../function/sync/apply-actions'
 import { generateServerDataStatus } from '../function/sync/get-server-data-status'
@@ -34,7 +34,7 @@ const getRoundedTimestampForLastConnectivity = () => {
 }
 
 export const createSyncRouter = ({ database, websocket, connectedDevicesManager, eventHandler }: {
-  database: Database
+  database: SimpleDatabase
   websocket: WebsocketApi
   connectedDevicesManager: VisibleConnectedDevicesManager
   eventHandler: EventHandler
@@ -86,12 +86,12 @@ export const createSyncRouter = ({ database, websocket, connectedDevicesManager,
       }
 
       const serverStatus = await database.transaction(async (transaction) => {
-        const deviceEntryUnsafe = await database.device.findOne({
+        const deviceEntryUnsafe = await transaction.legacy.database.device.findOne({
           where: {
             deviceAuthToken: body.deviceAuthToken
           },
           attributes: ['familyId', 'deviceId', 'lastConnectivity'],
-          transaction
+          transaction: transaction.legacy.transaction
         })
 
         if (!deviceEntryUnsafe) {
@@ -102,22 +102,21 @@ export const createSyncRouter = ({ database, websocket, connectedDevicesManager,
         const now = getRoundedTimestampForLastConnectivity()
 
         if (parseInt(lastConnectivity, 10) !== now) {
-          await database.device.update({
+          await transaction.legacy.database.device.update({
             lastConnectivity: now.toString(10)
           }, {
             where: {
               deviceAuthToken: body.deviceAuthToken
             },
-            transaction
+            transaction: transaction.legacy.transaction
           })
         }
 
         return generateServerDataStatus({
-          database,
+          transaction,
           familyId,
           deviceId,
           clientStatus: body.status,
-          transaction,
           eventHandler
         })
       })
@@ -165,11 +164,11 @@ export const createSyncRouter = ({ database, websocket, connectedDevicesManager,
       }
 
       const isDeviceRemoved: boolean = await database.transaction(async (transaction) => {
-        const removedEntry = await database.oldDevice.findOne({
+        const removedEntry = await transaction.legacy.database.oldDevice.findOne({
           where: {
             deviceAuthToken: req.body.deviceAuthToken
           },
-          transaction
+          transaction: transaction.legacy.transaction
         })
 
         return !!removedEntry

src/cli/delete-old-families.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -16,9 +16,10 @@
  */
 
 import { defaultDatabase } from '../database'
+import { fromLegacy as createSimpleDatabase } from '../database/simple'
 import { deleteOldFamilies } from '../function/cleanup/delete-old-families'
 
-const database = defaultDatabase
+const database = createSimpleDatabase(defaultDatabase)
 
 deleteOldFamilies(database)
   .then(() => console.log('done'))

src/cli/find-old-families.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -16,9 +16,10 @@
  */
 
 import { defaultDatabase } from '../database'
+import { fromLegacy as createSimpleDatabase } from '../database/simple'
 import { findOldFamilyIds } from '../function/cleanup/delete-old-families'
 
-const database = defaultDatabase
+const database = createSimpleDatabase(defaultDatabase)
 
 findOldFamilyIds(database)
   .then((res) => console.log(JSON.stringify(res)))

src/connected-devices/index.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -16,7 +16,7 @@
  */
 
 import { EventEmitter } from 'events'
-import { Database } from '../database'
+import { SimpleDatabase } from '../database/simple'
 
 export class ConnectedDevicesManager {
   private deviceConnectionCounters = new Map<string, number>()
@@ -59,10 +59,10 @@ export class ConnectedDevicesManager {
 
 export class VisibleConnectedDevicesManager {
   connectedDevicesManager = new ConnectedDevicesManager()
-  private database: Database
+  private database: SimpleDatabase
 
   constructor ({ database }: {
-    database: Database
+    database: SimpleDatabase
   }) {
     this.database = database
   }
@@ -174,19 +174,24 @@ export class VisibleConnectedDevicesManager {
 
     // add all current devices
     ;(async () => {
-      const devicesUnsafe = await this.database.device.findAll({
+      const devices = await this.database.transaction(async (transaction) => {
-        where: {
+        const devicesUnsafe = await transaction.legacy.database.device.findAll({
-          familyId
+          where: {
-        },
+            familyId
-        attributes: [
+          },
-          'deviceId',
+          attributes: [
-          'showDeviceConnected'
+            'deviceId',
-        ]
+            'showDeviceConnected'
-      })
+          ],
+          transaction: transaction.legacy.transaction
+        })
 
-      const devices = devicesUnsafe.map(({ deviceId, showDeviceConnected }) => ({
+        const devices = devicesUnsafe.map(({ deviceId, showDeviceConnected }) => ({
-        deviceId, showDeviceConnected
+          deviceId, showDeviceConnected
-      }))
+        }))
+
+        return devices
+      })
 
       devices.forEach(({ deviceId, showDeviceConnected }) => {
         addDevice({ deviceId, showDeviceConnected })

src/database/simple/index.ts

@@ -0,0 +1,59 @@
+/*
+ * server component for the TimeLimit App
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, version 3 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import { Database as LegacyDatabase, Transaction as LegacyTransaction } from '../main'
+
+export interface SimpleDatabase {
+  legacy: LegacyDatabase
+  transaction: <T> (
+    inner: (t: SimpleDatabaseTransaction) => Promise<T>
+  ) => Promise<T>
+}
+
+export interface SimpleDatabaseTransaction {
+  transaction: <T> (
+    inner: (t: SimpleDatabaseTransaction) => Promise<T>
+  ) => Promise<T>
+
+  enqueueAfterCommit(callback: () => void): void
+
+  legacy: {
+    database: LegacyDatabase
+    transaction: LegacyTransaction
+  }
+}
+
+export function fromLegacy(database: LegacyDatabase): SimpleDatabase {
+  return {
+    legacy: database,
+    transaction: (inner) => database.transaction((legacyTransaction) => inner(fromLegacyTransaction(database, legacyTransaction)))
+  }
+}
+
+function fromLegacyTransaction(database: LegacyDatabase, legacyTransaction: LegacyTransaction): SimpleDatabaseTransaction {
+  return {
+    transaction: (inner) => database.transaction(
+      (innerTransaction) => inner(fromLegacyTransaction(database, innerTransaction)),
+      { transaction: legacyTransaction }
+    ),
+    enqueueAfterCommit: (afterCommitAction) => legacyTransaction.afterCommit(afterCommitAction),
+    legacy: {
+      database,
+      transaction: legacyTransaction
+    }
+  }
+}

src/function/authentication/index.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2021 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -16,45 +16,45 @@
  */
 
 import { Unauthorized } from 'http-errors'
-import { Database, Transaction } from '../../database'
+import { SimpleDatabaseTransaction } from '../../database/simple'
 import { generateAuthToken } from '../../util/token'
 
 export const createAuthTokenByMailAddress = async ({
-  mail, database, transaction, locale
+  mail, transaction, locale
 }: {
-  mail: string, database: Database, transaction: Transaction, locale: string
+  mail: string, transaction: SimpleDatabaseTransaction, locale: string
 }) => {
   const token = generateAuthToken()
 
-  await database.authtoken.create({
+  await transaction.legacy.database.authtoken.create({
     token,
     mail,
     createdAt: Date.now().toString(),
     locale
-  }, { transaction })
+  }, { transaction: transaction.legacy.transaction })
 
   return token
 }
 
 export const getMailAndLocaleByAuthToken = async ({
-  mailAuthToken, database, transaction, invalidate
+  mailAuthToken, transaction, invalidate
 }: {
-  mailAuthToken: string, database: Database, transaction: Transaction, invalidate: boolean
+  mailAuthToken: string, transaction: SimpleDatabaseTransaction, invalidate: boolean
 }) => {
-  const entry = await database.authtoken.findOne({
+  const entry = await transaction.legacy.database.authtoken.findOne({
     where: {
       token: mailAuthToken
     },
-    transaction
+    transaction: transaction.legacy.transaction
   })
 
   if (entry) {
     if (invalidate) {
-      const rowCounter = await database.authtoken.destroy({
+      const rowCounter = await transaction.legacy.database.authtoken.destroy({
         where: {
           token: mailAuthToken
         },
-        transaction
+        transaction: transaction.legacy.transaction
       })
 
       if (rowCounter !== 1) {
@@ -72,11 +72,11 @@ export const getMailAndLocaleByAuthToken = async ({
 }
 
 export const requireMailAndLocaleByAuthToken = async ({
-  mailAuthToken, database, transaction, invalidate
+  mailAuthToken, transaction, invalidate
 }: {
-  mailAuthToken: string, database: Database, transaction: Transaction, invalidate: boolean
+  mailAuthToken: string, transaction: SimpleDatabaseTransaction, invalidate: boolean
 }) => {
-  const result = await getMailAndLocaleByAuthToken({ mailAuthToken, database, transaction, invalidate })
+  const result = await getMailAndLocaleByAuthToken({ mailAuthToken, transaction, invalidate })
 
   if (!result) {
     throw new Unauthorized()

src/function/authentication/login-by-mail.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2023 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -16,7 +16,7 @@
  */
 
 import { Forbidden, Gone, TooManyRequests, Unauthorized } from 'http-errors'
-import { Database } from '../../database'
+import { SimpleDatabase } from '../../database/simple'
 import { sendAuthenticationMail } from '../../util/mail'
 import { areWordSequencesEqual, randomWords } from '../../util/random-words'
 import { checkMailSendLimit } from '../../util/ratelimit-authmail'
@@ -27,17 +27,17 @@ export const sendLoginCode = async ({ mail, deviceAuthToken, locale, database }:
   mail: string
   deviceAuthToken?: string
   locale: string
-  database: Database
+  database: SimpleDatabase
   // no transaction here because this is directly called from an API endpoint
 }): Promise<{ mailLoginToken: string }> => {
   let deviceName = null
 
   if (deviceAuthToken !== undefined) {
     const info = await database.transaction(async (transaction) => {
-      const deviceEntryUnsafe = await database.device.findOne({
+      const deviceEntryUnsafe = await transaction.legacy.database.device.findOne({
         where: { deviceAuthToken },
         attributes: ['familyId', 'name'],
-        transaction
+        transaction: transaction.legacy.transaction
       })
 
       if (!deviceEntryUnsafe) {
@@ -49,12 +49,12 @@ export const sendLoginCode = async ({ mail, deviceAuthToken, locale, database }:
         name: deviceEntryUnsafe.name
       }
 
-      const userEntryCounter = await database.user.count({
+      const userEntryCounter = await transaction.legacy.database.user.count({
         where: {
           familyId: deviceEntry.familyId,
           mail
         },
-        transaction
+        transaction: transaction.legacy.transaction
       })
 
       if (userEntryCounter === 1) {
@@ -86,14 +86,14 @@ export const sendLoginCode = async ({ mail, deviceAuthToken, locale, database }:
   })
 
   await database.transaction(async (transaction) => {
-    await database.mailLoginToken.create({
+    await transaction.legacy.database.mailLoginToken.create({
       mailLoginToken,
       receivedCode: code,
       mail,
       createdAt: Date.now().toString(10),
       remainingAttempts: 3,
       locale
-    }, { transaction })
+    }, { transaction: transaction.legacy.transaction })
   })
 
   return {
@@ -106,15 +106,15 @@ export const sendLoginCode = async ({ mail, deviceAuthToken, locale, database }:
 export const signInByMailCode = async ({ mailLoginToken, receivedCode, database }: {
   mailLoginToken: string
   receivedCode: string
-  database: Database
+  database: SimpleDatabase
   // no transaction here because this is directly called from an API endpoint
 }): Promise<{ mailAuthToken: string }> => {
   const result = await database.transaction(async (transaction) => {
-    const entry = await database.mailLoginToken.findOne({
+    const entry = await transaction.legacy.database.mailLoginToken.findOne({
       where: {
         mailLoginToken
       },
-      transaction
+      transaction: transaction.legacy.transaction
     })
 
     if ((!entry) || entry.remainingAttempts === 0) {
@@ -124,7 +124,7 @@ export const signInByMailCode = async ({ mailLoginToken, receivedCode, database
     if (!areWordSequencesEqual(entry.receivedCode, receivedCode)) {
       entry.remainingAttempts--
 
-      await entry.save({ transaction })
+      await entry.save({ transaction: transaction.legacy.transaction })
 
       if (entry.remainingAttempts === 0) {
         return () => { throw new Gone() }
@@ -133,11 +133,11 @@ export const signInByMailCode = async ({ mailLoginToken, receivedCode, database
       }
     }
 
-    const counter = await database.mailLoginToken.destroy({
+    const counter = await transaction.legacy.database.mailLoginToken.destroy({
       where: {
         mailLoginToken
       },
-      transaction
+      transaction: transaction.legacy.transaction
     })
 
     if (counter !== 1) {
@@ -147,7 +147,6 @@ export const signInByMailCode = async ({ mailLoginToken, receivedCode, database
     const mailAuthToken = await createAuthTokenByMailAddress({
       mail: entry.mail,
       locale: entry.locale,
-      database,
       transaction
     })
 

src/function/child/add-device.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -17,7 +17,7 @@
 
 import { Unauthorized } from 'http-errors'
 import { RegisterChildDeviceRequest } from '../../api/schema'
-import { Database } from '../../database'
+import { SimpleDatabase } from '../../database/simple'
 import { generateAuthToken, generateVersionId } from '../../util/token'
 import { WebsocketApi } from '../../websocket'
 import { prepareDeviceEntry } from '../device/prepare-device-entry'
@@ -28,7 +28,7 @@ import { ServerDataStatus } from '../../object/serverdatastatus'
 import { createEmptyClientDataStatus } from '../../object/clientdatastatus'
 
 export const addChildDevice = async ({ database, eventHandler, websocket, request }: {
-  database: Database
+  database: SimpleDatabase
   eventHandler: EventHandler
   websocket: WebsocketApi
   request: RegisterChildDeviceRequest
@@ -39,23 +39,23 @@ export const addChildDevice = async ({ database, eventHandler, websocket, reques
   data: ServerDataStatus
 }> => {
   return database.transaction(async (transaction) => {
-    const entry = await database.addDeviceToken.findOne({
+    const entry = await transaction.legacy.database.addDeviceToken.findOne({
       where: {
         token: request.registerToken.toLowerCase()
       },
-      transaction
+      transaction: transaction.legacy.transaction
     })
 
     if (!entry) {
       throw new Unauthorized()
     }
 
-    await entry.destroy({ transaction })
+    await entry.destroy({ transaction: transaction.legacy.transaction })
 
     const { deviceId, familyId } = entry
     const deviceAuthToken = generateAuthToken()
 
-    await database.device.create(prepareDeviceEntry({
+    await transaction.legacy.database.device.create(prepareDeviceEntry({
       familyId,
       deviceId,
       deviceAuthToken,
@@ -63,33 +63,31 @@ export const addChildDevice = async ({ database, eventHandler, websocket, reques
       newDeviceInfo: request.childDevice,
       userId: '',
       isUserKeptSignedIn: false
-    }), { transaction })
+    }), { transaction: transaction.legacy.transaction })
 
-    await database.family.update({
+    await transaction.legacy.database.family.update({
       deviceListVersion: generateVersionId()
     }, {
       where: {
         familyId
       },
-      transaction
+      transaction: transaction.legacy.transaction
     })
 
     await notifyClientsAboutChangesDelayed({
       familyId,
       websocket,
-      database,
+      transaction,
       generalLevel: 1,
       targetedLevels: new Map(),
-      sourceDeviceId: deviceId,
+      sourceDeviceId: deviceId
-      transaction
     })
 
     const data = await generateServerDataStatus({
-      database,
+      transaction,
       clientStatus: createEmptyClientDataStatus({ clientLevel: request.clientLevel || null }),
       familyId: entry.familyId,
       deviceId,
-      transaction,
       eventHandler
     })
 

src/function/child/logout-at-primary-device.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2020 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -16,21 +16,21 @@
  */
 
 import { Conflict, Unauthorized } from 'http-errors'
-import { Database } from '../../database'
+import { SimpleDatabase } from '../../database/simple'
 import { WebsocketApi } from '../../websocket'
 
 export const logoutAtPrimaryDevice = async ({ deviceAuthToken, database, websocket }: {
   deviceAuthToken: string
-  database: Database
+  database: SimpleDatabase
   websocket: WebsocketApi
   // no transaction here because this is directly called from an API endpoint
 }) => {
   await database.transaction(async (transaction) => {
-    const ownDeviceEntryUnsafe = await database.device.findOne({
+    const ownDeviceEntryUnsafe = await transaction.legacy.database.device.findOne({
       where: {
         deviceAuthToken
       },
-      transaction,
+      transaction: transaction.legacy.transaction,
       attributes: ['familyId', 'currentUserId', 'deviceId']
     })
 
@@ -43,14 +43,14 @@ export const logoutAtPrimaryDevice = async ({ deviceAuthToken, database, websock
       currentUserId: ownDeviceEntryUnsafe.currentUserId
     }
 
-    const deviceUserEntryUnsafe = await database.user.findOne({
+    const deviceUserEntryUnsafe = await transaction.legacy.database.user.findOne({
       where: {
         familyId: ownDeviceEntry.familyId,
         userId: ownDeviceEntry.currentUserId,
         type: 'child'
       },
       attributes: ['currentDevice'],
-      transaction
+      transaction: transaction.legacy.transaction
     })
 
     if (!deviceUserEntryUnsafe) {
@@ -61,14 +61,14 @@ export const logoutAtPrimaryDevice = async ({ deviceAuthToken, database, websock
       currentDevice: deviceUserEntryUnsafe.currentDevice
     }
 
-    const otherDeviceEntryUnsafe = await database.device.findOne({
+    const otherDeviceEntryUnsafe = await transaction.legacy.database.device.findOne({
       where: {
         familyId: ownDeviceEntry.familyId,
         deviceId: deviceUserEntry.currentDevice,
         currentUserId: ownDeviceEntry.currentUserId
       },
       attributes: ['deviceAuthToken'],
-      transaction
+      transaction: transaction.legacy.transaction
     })
 
     if (!otherDeviceEntryUnsafe) {

src/function/child/set-primary-device.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -17,13 +17,13 @@
 
 import { Conflict, InternalServerError, Unauthorized } from 'http-errors'
 import { config } from '../../config'
-import { Database } from '../../database'
+import { SimpleDatabase } from '../../database/simple'
 import { generateVersionId } from '../../util/token'
 import { WebsocketApi } from '../../websocket'
 import { notifyClientsAboutChangesDelayed } from '../websocket'
 
 export const setPrimaryDevice = async ({ database, websocket, deviceAuthToken, currentUserId, action }: {
-  database: Database
+  database: SimpleDatabase
   websocket: WebsocketApi
   deviceAuthToken: string
   currentUserId: string
@@ -31,11 +31,11 @@ export const setPrimaryDevice = async ({ database, websocket, deviceAuthToken, c
   // no transaction here because this is directly called from an API endpoint
 }): Promise<'assigned to other device' | 'requires full version' | 'success'> => {
   return database.transaction(async (transaction): Promise<'assigned to other device' | 'requires full version' | 'success'> => {
-    const deviceEntryUnsafe = await database.device.findOne({
+    const deviceEntryUnsafe = await transaction.legacy.database.device.findOne({
       where: {
         deviceAuthToken
       },
-      transaction,
+      transaction: transaction.legacy.transaction,
       attributes: ['familyId', 'currentUserId', 'deviceId']
     })
 
@@ -53,12 +53,12 @@ export const setPrimaryDevice = async ({ database, websocket, deviceAuthToken, c
       throw new Conflict()
     }
 
-    const userEntryUnsafe = await database.user.findOne({
+    const userEntryUnsafe = await transaction.legacy.database.user.findOne({
       where: {
         familyId: deviceEntry.familyId,
         userId: deviceEntry.currentUserId
       },
-      transaction,
+      transaction: transaction.legacy.transaction,
       attributes: ['currentDevice']
     })
 
@@ -70,12 +70,12 @@ export const setPrimaryDevice = async ({ database, websocket, deviceAuthToken, c
       currentDevice: userEntryUnsafe.currentDevice
     }
 
-    const userDeviceEntriesUnsafe = await database.device.findAll({
+    const userDeviceEntriesUnsafe = await transaction.legacy.database.device.findAll({
       where: {
         familyId: deviceEntry.familyId,
         currentUserId
       },
-      transaction,
+      transaction: transaction.legacy.transaction,
       attributes: ['deviceId']
     })
 
@@ -84,11 +84,11 @@ export const setPrimaryDevice = async ({ database, websocket, deviceAuthToken, c
     }))
 
     if (userDeviceEntries.length >= 2) {
-      const familyEntryUnsafe = await database.family.findOne({
+      const familyEntryUnsafe = await transaction.legacy.database.family.findOne({
         where: {
           familyId: deviceEntry.familyId
         },
-        transaction,
+        transaction: transaction.legacy.transaction,
         attributes: ['hasFullVersion']
       })
 
@@ -112,14 +112,14 @@ export const setPrimaryDevice = async ({ database, websocket, deviceAuthToken, c
       }
 
       // update
-      const [affectedRows] = await database.user.update({
+      const [affectedRows] = await transaction.legacy.database.user.update({
         currentDevice: deviceEntry.deviceId
       }, {
         where: {
           familyId: deviceEntry.familyId,
           userId: currentUserId
         },
-        transaction
+        transaction: transaction.legacy.transaction
       })
 
       if (affectedRows !== 1) {
@@ -131,14 +131,14 @@ export const setPrimaryDevice = async ({ database, websocket, deviceAuthToken, c
       }
 
       // update
-      const [affectedRows] = await database.user.update({
+      const [affectedRows] = await transaction.legacy.database.user.update({
         currentDevice: ''
       }, {
         where: {
           familyId: deviceEntry.familyId,
           userId: currentUserId
         },
-        transaction
+        transaction: transaction.legacy.transaction
       })
 
       if (affectedRows !== 1) {
@@ -149,10 +149,10 @@ export const setPrimaryDevice = async ({ database, websocket, deviceAuthToken, c
     }
 
     // invalidiate user list
-    await database.family.update({
+    await transaction.legacy.database.family.update({
       userListVersion: generateVersionId()
     }, {
-      transaction,
+      transaction: transaction.legacy.transaction,
       where: {
         familyId: deviceEntry.familyId
       }
@@ -163,10 +163,9 @@ export const setPrimaryDevice = async ({ database, websocket, deviceAuthToken, c
       familyId: deviceEntry.familyId,
       sourceDeviceId: deviceEntry.deviceId,
       websocket,
-      database,
+      transaction,
       generalLevel: 1,  // the source device knows it already
       targetedLevels: new Map(),
-      transaction
     })
 
     return 'success'

src/function/cleanup/account-deletion.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2023 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -17,7 +17,7 @@
 
 import { Unauthorized } from 'http-errors'
 import { DeleteAccountPayload } from '../../api/schema'
-import { Database } from '../../database'
+import { SimpleDatabase } from '../../database/simple'
 import { sendAccountDeletedMail } from '../../util/mail'
 import { WebsocketApi } from '../../websocket'
 import { requireMailAndLocaleByAuthToken } from '../authentication'
@@ -25,14 +25,14 @@ import { deleteFamilies } from './delete-families'
 
 export async function deleteAccount({ request, database, websocket }: {
   request: DeleteAccountPayload
-  database: Database
+  database: SimpleDatabase
   websocket: WebsocketApi
 }) {
   await database.transaction(async (transaction) => {
-    const deviceEntryUnsafe = await database.device.findOne({
+    const deviceEntryUnsafe = await transaction.legacy.database.device.findOne({
       where: { deviceAuthToken: request.deviceAuthToken },
       attributes: ['familyId'],
-      transaction
+      transaction: transaction.legacy.transaction
     })
 
     if (!deviceEntryUnsafe) {
@@ -43,13 +43,13 @@ export async function deleteAccount({ request, database, websocket }: {
       familyId: deviceEntryUnsafe.familyId
     }
 
-    const userEntries = (await database.user.findAll({
+    const userEntries = (await transaction.legacy.database.user.findAll({
       where: {
         familyId: deviceEntry.familyId,
         type: 'parent'
       },
       attributes: ['mail'],
-      transaction
+      transaction: transaction.legacy.transaction
     })).map((item) => ({ mail: item.mail }))
 
     const registeredMailAddresses = new Set<string>()
@@ -63,7 +63,6 @@ export async function deleteAccount({ request, database, websocket }: {
     for (const mailAuthToken of request.mailAuthTokens) {
       const info = await requireMailAndLocaleByAuthToken({
         mailAuthToken,
-        database,
         transaction,
         invalidate: true
       })
@@ -79,17 +78,17 @@ export async function deleteAccount({ request, database, websocket }: {
       if (!authenticatedMailAddresses.has(mail)) throw new Unauthorized()
     })
 
-    const deviceEntries = (await database.device.findAll({
+    const deviceEntries = (await transaction.legacy.database.device.findAll({
       where: {
         familyId: deviceEntry.familyId
       },
-      transaction,
+      transaction: transaction.legacy.transaction,
       attributes: ['deviceAuthToken']
     })).map((item) => ({ deviceAuthToken: item.deviceAuthToken }))
 
-    await deleteFamilies({ database, transaction, familiyIds: [deviceEntry.familyId] })
+    await deleteFamilies({ transaction, familiyIds: [deviceEntry.familyId] })
 
-    transaction.afterCommit(() => {
+    transaction.enqueueAfterCommit(() => {
       for (const device of deviceEntries) {
         websocket.triggerSyncByDeviceAuthToken({
           deviceAuthToken: device.deviceAuthToken,

src/function/cleanup/delete-families.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2023 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -17,138 +17,136 @@
 
 import { difference } from 'lodash'
 import * as Sequelize from 'sequelize'
-import { Database, Transaction } from '../../database'
+import { SimpleDatabaseTransaction } from '../../database/simple'
 
-export async function deleteFamilies ({ database, transaction, familiyIds }: {
+export async function deleteFamilies ({ transaction, familiyIds }: {
-  database: Database
+  transaction: SimpleDatabaseTransaction
-  transaction: Transaction
   familiyIds: Array<string>
-  // no transaction here because this should run isolated
 }) {
   if (familiyIds.length === 0) {
     return
   }
 
   // category
-  await database.category.destroy({
+  await transaction.legacy.database.category.destroy({
     where: {
       familyId: {
         [Sequelize.Op.in]: familiyIds
       }
     },
-    transaction
+    transaction: transaction.legacy.transaction
   })
 
   // categoryapp
-  await database.categoryApp.destroy({
+  await transaction.legacy.database.categoryApp.destroy({
     where: {
       familyId: {
         [Sequelize.Op.in]: familiyIds
       }
     },
-    transaction
+    transaction: transaction.legacy.transaction
   })
 
   // purchase
-  await database.purchase.destroy({
+  await transaction.legacy.database.purchase.destroy({
     where: {
       familyId: {
         [Sequelize.Op.in]: familiyIds
       }
     },
-    transaction
+    transaction: transaction.legacy.transaction
   })
 
   // timelimitrule
-  await database.timelimitRule.destroy({
+  await transaction.legacy.database.timelimitRule.destroy({
     where: {
       familyId: {
         [Sequelize.Op.in]: familiyIds
       }
     },
-    transaction
+    transaction: transaction.legacy.transaction
   })
 
   // usedtime
-  await database.usedTime.destroy({
+  await transaction.legacy.database.usedTime.destroy({
     where: {
       familyId: {
         [Sequelize.Op.in]: familiyIds
       }
     },
-    transaction
+    transaction: transaction.legacy.transaction
   })
 
   // session durations
-  await database.sessionDuration.destroy({
+  await transaction.legacy.database.sessionDuration.destroy({
     where: {
       familyId: {
         [Sequelize.Op.in]: familiyIds
       }
     },
-    transaction
+    transaction: transaction.legacy.transaction
   })
 
   // user
-  await database.user.destroy({
+  await transaction.legacy.database.user.destroy({
     where: {
       familyId: {
         [Sequelize.Op.in]: familiyIds
       }
     },
-    transaction
+    transaction: transaction.legacy.transaction
   })
 
   // device
-  const oldDeviceAuthTokens = (await database.device.findAll({
+  const oldDeviceAuthTokens = (await transaction.legacy.database.device.findAll({
     where: {
       familyId: {
         [Sequelize.Op.in]: familiyIds
       }
     },
     attributes: ['deviceAuthToken'],
-    transaction
+    transaction: transaction.legacy.transaction
   })).map((item) => item.deviceAuthToken)
 
-  await database.device.destroy({
+  await transaction.legacy.database.device.destroy({
     where: {
       familyId: {
         [Sequelize.Op.in]: familiyIds
       }
     },
-    transaction
+    transaction: transaction.legacy.transaction
   })
 
   // olddevice
   if (oldDeviceAuthTokens.length > 0) {
-    const knownOldDeviceAuthTokens = (await database.oldDevice.findAll({
+    const knownOldDeviceAuthTokens = (await transaction.legacy.database.oldDevice.findAll({
       where: {
         deviceAuthToken: {
           [Sequelize.Op.in]: oldDeviceAuthTokens
         }
       },
-      transaction
+      transaction: transaction.legacy.transaction
     })).map((item) => item.deviceAuthToken)
 
     const oldDeviceAuthTokensToAdd = difference(oldDeviceAuthTokens, knownOldDeviceAuthTokens)
 
     if (oldDeviceAuthTokensToAdd.length > 0) {
-      await database.oldDevice.bulkCreate(
+      await transaction.legacy.database.oldDevice.bulkCreate(
         oldDeviceAuthTokensToAdd.map((item) => ({
           deviceAuthToken: item
         })),
-        { transaction }
+        { transaction: transaction.legacy.transaction }
       )
     }
   }
 
   // family
-  await database.family.destroy({
+  await transaction.legacy.database.family.destroy({
     where: {
       familyId: {
         [Sequelize.Op.in]: familiyIds
       }
     },
-    transaction
+    transaction: transaction.legacy.transaction
   })
 }

src/function/cleanup/delete-old-families.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2023 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -17,10 +17,10 @@
 
 import { difference } from 'lodash'
 import * as Sequelize from 'sequelize'
-import { Database } from '../../database'
+import { SimpleDatabase } from '../../database/simple'
 import { deleteFamilies } from './delete-families'
 
-export async function deleteOldFamilies (database: Database) {
+export async function deleteOldFamilies (database: SimpleDatabase) {
   const oldFamilyIds = await findOldFamilyIds(database)
 
   if (oldFamilyIds.length > 0) {
@@ -28,7 +28,6 @@ export async function deleteOldFamilies (database: Database) {
 
     await database.transaction(async (transaction) => {
       await deleteFamilies({
-        database,
         transaction,
         familiyIds: familyIdsToDelete
       })
@@ -36,23 +35,23 @@ export async function deleteOldFamilies (database: Database) {
   }
 }
 
-export async function findOldFamilyIds (database: Database) {
+export async function findOldFamilyIds (database: SimpleDatabase): Promise<Array<string>> {
   return database.transaction(async (transaction) => {
-    const familyIdsWithExpiredLicenses = (await database.family.findAll({
+    const familyIdsWithExpiredLicenses = (await transaction.legacy.database.family.findAll({
       where: {
         fullVersionUntil: {
           [Sequelize.Op.lt]: (Date.now() - 1000 * 60 * 60 * 24 * 90 /* 90 days */).toString(10)
         }
       },
       attributes: ['familyId'],
-      transaction
+      transaction: transaction.legacy.transaction
     })).map((item) => item.familyId)
 
     if (familyIdsWithExpiredLicenses.length === 0) {
       return []
     }
 
-    const recentlyUsedFamilyIds = (await database.device.findAll({
+    const recentlyUsedFamilyIds = (await transaction.legacy.database.device.findAll({
       where: {
         familyId: {
           [Sequelize.Op.in]: familyIdsWithExpiredLicenses
@@ -62,7 +61,7 @@ export async function findOldFamilyIds (database: Database) {
         }
       },
       attributes: ['familyId'],
-      transaction
+      transaction: transaction.legacy.transaction
     })).map((item) => item.familyId)
 
     return difference(familyIdsWithExpiredLicenses, recentlyUsedFamilyIds)

src/function/device/remove-device.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -16,24 +16,23 @@
  */
 
 import { Conflict } from 'http-errors'
-import { Database, Transaction } from '../../database'
+import { SimpleDatabaseTransaction } from '../../database/simple'
 import { generateVersionId } from '../../util/token'
 import { WebsocketApi } from '../../websocket'
 import { notifyClientsAboutChangesDelayed } from '../websocket'
 
-export async function removeDevice ({ database, familyId, deviceId, websocket, transaction }: {
+export async function removeDevice ({ familyId, deviceId, websocket, transaction }: {
-  database: Database
+  transaction: SimpleDatabaseTransaction
   familyId: string
   deviceId: string
   websocket: WebsocketApi
-  transaction: Transaction
 }) {
-  const deviceEntry = await database.device.findOne({
+  const deviceEntry = await transaction.legacy.database.device.findOne({
     where: {
       familyId,
       deviceId
     },
-    transaction
+    transaction: transaction.legacy.transaction
   })
 
   if (!deviceEntry) {
@@ -41,37 +40,37 @@ export async function removeDevice ({ database, familyId, deviceId, websocket, t
   }
 
   // remove as current device
-  await database.user.update({
+  await transaction.legacy.database.user.update({
     currentDevice: ''
   }, {
     where: {
       familyId,
       currentDevice: deviceId
     },
-    transaction
+    transaction: transaction.legacy.transaction
   })
 
   // add to old devices if it is not yet there (it could be there if it reported a uninstall)
-  const oldOldDeviceEntry = await database.oldDevice.findOne({
+  const oldOldDeviceEntry = await transaction.legacy.database.oldDevice.findOne({
     where: {
       deviceAuthToken: deviceEntry.deviceAuthToken
     },
-    transaction
+    transaction: transaction.legacy.transaction
   })
 
   if (!oldOldDeviceEntry) {
-    await database.oldDevice.create({
+    await transaction.legacy.database.oldDevice.create({
       deviceAuthToken: deviceEntry.deviceAuthToken
     }, {
-      transaction
+      transaction: transaction.legacy.transaction
     })
   }
 
   // remove from the device list
-  await deviceEntry.destroy({ transaction })
+  await deviceEntry.destroy({ transaction: transaction.legacy.transaction })
 
   // invalidiate the caches
-  await database.family.update({
+  await transaction.legacy.database.family.update({
     deviceListVersion: generateVersionId(),
     // the device could have become unassigned during this
     userListVersion: generateVersionId()
@@ -79,20 +78,19 @@ export async function removeDevice ({ database, familyId, deviceId, websocket, t
     where: {
       familyId: deviceEntry.familyId
     },
-    transaction
+    transaction: transaction.legacy.transaction
   })
 
   await notifyClientsAboutChangesDelayed({
-    database,
+    transaction,
     websocket,
     familyId,
     sourceDeviceId: null,
     generalLevel: 1,
-    targetedLevels: new Map(),
+    targetedLevels: new Map()
-    transaction
   })
 
-  transaction.afterCommit(() => {
+  transaction.enqueueAfterCommit(() => {
     websocket.triggerSyncByDeviceAuthToken({
       deviceAuthToken: deviceEntry.deviceAuthToken,
       isImportant: true

src/function/device/report-device-removed.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -16,24 +16,24 @@
  */
 
 import { Unauthorized } from 'http-errors'
-import { Database } from '../../database'
+import { SimpleDatabase } from '../../database/simple'
 import { generateAuthToken, generateVersionId } from '../../util/token'
 import { WebsocketApi } from '../../websocket'
 import { sendUninstallWarnings } from '../warningmail/uninstall'
 import { notifyClientsAboutChangesDelayed } from '../websocket'
 
 export async function reportDeviceRemoved ({ database, deviceAuthToken, websocket }: {
-  database: Database
+  database: SimpleDatabase
   deviceAuthToken: string
   websocket: WebsocketApi
   // no transaction here because this is directly called from an API endpoint
 }) {
   await database.transaction(async (transaction) => {
-    const deviceEntry = await database.device.findOne({
+    const deviceEntry = await transaction.legacy.database.device.findOne({
       where: {
         deviceAuthToken
       },
-      transaction
+      transaction: transaction.legacy.transaction
     })
 
     if (deviceEntry) {
@@ -41,47 +41,45 @@ export async function reportDeviceRemoved ({ database, deviceAuthToken, websocke
 
       deviceEntry.didDeviceReportUninstall = true
       deviceEntry.deviceAuthToken = generateAuthToken() // invalidiate the token
-      await deviceEntry.save({ transaction })
+      await deviceEntry.save({ transaction: transaction.legacy.transaction })
 
       // invalidiate device list
-      await database.family.update({
+      await transaction.legacy.database.family.update({
         deviceListVersion: generateVersionId()
       }, {
         where: {
           familyId: deviceEntry.familyId
         },
-        transaction
+        transaction: transaction.legacy.transaction
       })
 
       // add to old devices
-      await database.oldDevice.create({
+      await transaction.legacy.database.oldDevice.create({
         deviceAuthToken: currentAuthToken
       }, {
-        transaction
+        transaction: transaction.legacy.transaction
       })
 
       await notifyClientsAboutChangesDelayed({
-        database,
+        transaction,
         websocket,
         familyId: deviceEntry.familyId,
         sourceDeviceId: null,
         generalLevel: 1,
         targetedLevels: new Map(),
-        transaction
       })
 
       await sendUninstallWarnings({
-        database,
+        transaction,
         familyId: deviceEntry.familyId,
         deviceName: deviceEntry.name,
-        transaction
       })
     } else {
-      const oldDeviceEntry = await database.oldDevice.findOne({
+      const oldDeviceEntry = await transaction.legacy.database.oldDevice.findOne({
         where: {
           deviceAuthToken
         },
-        transaction
+        transaction: transaction.legacy.transaction
       })
 
       if (!oldDeviceEntry) {

src/function/dh/decrypt.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -15,17 +15,15 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-import * as Sequelize from 'sequelize'
 import { createDecipheriv } from 'crypto'
-import { Database } from '../../database'
+import { SimpleDatabaseTransaction } from '../../database/simple'
 import { isVersionId } from '../../util/token'
 import { getSharedSecret, SharedSecretException } from './shared-secret'
 
 export async function decrypt({
-  database, transaction, familyId, deviceId, encryptedData, authData
+  transaction, familyId, deviceId, encryptedData, authData
 }: {
-  database: Database
+  transaction: SimpleDatabaseTransaction
-  transaction: Sequelize.Transaction
   familyId: string
   deviceId: string
   encryptedData: string
@@ -46,7 +44,6 @@ export async function decrypt({
   const sharedSecret = await (async () => {
     try {
       return getSharedSecret({
-        database,
         transaction,
         familyId,
         deviceId,

src/function/dh/parentpassword.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -31,7 +31,6 @@ export async function decryptParentPassword({ cache, password } : {
 
   try {
     const secondHash = (await decrypt({
-      database: cache.database,
       transaction: cache.transaction,
       familyId: cache.familyId,
       deviceId: cache.deviceId,

src/function/dh/shared-secret.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -15,17 +15,15 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-import * as Sequelize from 'sequelize'
 import { createPrivateKey, createPublicKey, diffieHellman } from 'crypto'
-import { Database } from '../../database'
+import { SimpleDatabaseTransaction } from '../../database/simple'
 import { calculateExpireTime } from '../../database/devicedhkey'
 import { isVersionId } from '../../util/token'
 
 export async function getSharedSecret({
-  database, transaction, familyId, deviceId, keyId, otherPublicKey
+  transaction, familyId, deviceId, keyId, otherPublicKey
 }: {
-  database: Database
+  transaction: SimpleDatabaseTransaction
-  transaction: Sequelize.Transaction
   familyId: string
   deviceId: string
   keyId: string
@@ -33,20 +31,20 @@ export async function getSharedSecret({
 }) {
   if (!isVersionId(keyId)) throw new KeyNotFoundException('invalid key id')
 
-  const databaseKeyEntry = await database.deviceDhKey.findOne({
+  const databaseKeyEntry = await transaction.legacy.database.deviceDhKey.findOne({
     where: {
       familyId,
       deviceId,
       version: keyId
     },
-    transaction
+    transaction: transaction.legacy.transaction
   })
 
   if (!databaseKeyEntry) throw new KeyNotFoundException('private key not found')
 
   if (databaseKeyEntry.expireAt === null) {
     databaseKeyEntry.expireAt = calculateExpireTime(BigInt(Date.now())).toString(10)
-    await databaseKeyEntry.save({ transaction })
+    await databaseKeyEntry.save({ transaction: transaction.legacy.transaction })
   } else {
     if (BigInt(databaseKeyEntry.expireAt) < BigInt(Date.now())) throw new KeyExpiredException()
   }

src/function/parent/create-add-device-token.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2020 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -15,31 +15,30 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-import { Database, Transaction } from '../../database'
+import { SimpleDatabaseTransaction } from '../../database/simple'
 import { randomWords } from '../../util/random-words'
 import { generateIdWithinFamily } from '../../util/token'
 
-export const createAddDeviceToken = async ({ familyId, database, transaction }: {
+export const createAddDeviceToken = async ({ familyId, transaction }: {
   familyId: string
-  database: Database
+  transaction: SimpleDatabaseTransaction
-  transaction: Transaction
 }) => {
   const token = randomWords(5)
   const deviceId = generateIdWithinFamily()
 
-  await database.addDeviceToken.destroy({
+  await transaction.legacy.database.addDeviceToken.destroy({
     where: {
       familyId
     },
-    transaction
+    transaction: transaction.legacy.transaction
   })
 
-  await database.addDeviceToken.create({
+  await transaction.legacy.database.addDeviceToken.create({
     familyId,
     token: token.toLowerCase(),
     deviceId,
     createdAt: Date.now().toString()
-  }, { transaction })
+  }, { transaction: transaction.legacy.transaction })
 
   return { token, deviceId }
 }

src/function/parent/create-family.ts

@@ -18,7 +18,7 @@
 import { Conflict } from 'http-errors'
 import { generateServerDataStatus } from '../sync/get-server-data-status'
 import { NewDeviceInfo, PlaintextParentPassword, assertPlaintextParentPasswordValid } from '../../api/schema'
-import { Database } from '../../database'
+import { SimpleDatabase } from '../../database/simple'
 import { maxMailNotificationFlags } from '../../database/user'
 import { EventHandler } from '../../monitoring/eventhandler'
 import { ServerDataStatus } from '../../object/serverdatastatus'
@@ -33,7 +33,7 @@ export async function createFamily ({
   database, eventHandler, mailAuthToken, firstParentDevice,
   password, timeZone, parentName, deviceName, clientLevel
 }: {
-  database: Database
+  database: SimpleDatabase
   eventHandler: EventHandler
   mailAuthToken: string
   firstParentDevice: NewDeviceInfo
@@ -52,14 +52,14 @@ export async function createFamily ({
 
   return database.transaction(async (transaction) => {
     const now = Date.now().toString(10)
-    const mailInfo = await requireMailAndLocaleByAuthToken({ database, mailAuthToken, transaction, invalidate: true })
+    const mailInfo = await requireMailAndLocaleByAuthToken({ transaction, mailAuthToken, invalidate: true })
 
     // ensure that no family was created for this mail yet
-    const existingUserEntry = await database.user.findOne({
+    const existingUserEntry = await transaction.legacy.database.user.findOne({
       where: {
         mail: mailInfo.mail
       },
-      transaction
+      transaction: transaction.legacy.transaction
     })
 
     if (existingUserEntry) {
@@ -72,7 +72,7 @@ export async function createFamily ({
     const deviceAuthToken = generateAuthToken()
 
     // create family
-    await database.family.create({
+    await transaction.legacy.database.family.create({
       familyId,
       name: '',
       createdAt: now,
@@ -84,10 +84,10 @@ export async function createFamily ({
       nextServerKeyRequestSeq: '1',
       u2fKeysVersion: generateVersionId(),
       fullVersionDebts: '0'
-    }, { transaction })
+    }, { transaction: transaction.legacy.transaction })
 
     // create parent user
-    await database.user.create({
+    await transaction.legacy.database.user.create({
       familyId,
       userId,
       name: parentName,
@@ -104,10 +104,10 @@ export async function createFamily ({
       mailNotificationFlags: maxMailNotificationFlags,
       blockedTimes: '',
       flags: '0'
-    }, { transaction })
+    }, { transaction: transaction.legacy.transaction })
 
     // add parent device
-    await database.device.create(prepareDeviceEntry({
+    await transaction.legacy.database.device.create(prepareDeviceEntry({
       familyId,
       deviceId,
       deviceName,
@@ -115,14 +115,13 @@ export async function createFamily ({
       userId,
       deviceAuthToken,
       isUserKeptSignedIn: true
-    }), { transaction })
+    }), { transaction: transaction.legacy.transaction })
 
     const data = await generateServerDataStatus({
-      database,
+      transaction,
       clientStatus: createEmptyClientDataStatus({ clientLevel }),
       familyId,
       deviceId,
-      transaction,
       eventHandler
     })
 

src/function/parent/get-status-by-mail-address.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2021 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -15,22 +15,22 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-import { Database, Transaction } from '../../database'
+import { SimpleDatabaseTransaction } from '../../database/simple'
 import { StaticMessageException } from '../../exception'
 import { requireMailAndLocaleByAuthToken } from '../authentication'
 
 const getStatusByMailAddress = async ({
-  mail, database, transaction
+  mail, transaction
-}: { mail: string, database: Database, transaction: Transaction }) => {
+}: { mail: string, transaction: SimpleDatabaseTransaction }) => {
   if (!mail) {
     throw new StaticMessageException({ staticMessage: 'getStatusByMailAddress: no mail address provided' })
   }
 
-  const entry = await database.user.findOne({
+  const entry = await transaction.legacy.database.user.findOne({
     where: {
       mail
     },
-    transaction
+    transaction: transaction.legacy.transaction
   })
 
   if (entry) {
@@ -41,12 +41,12 @@ const getStatusByMailAddress = async ({
 }
 
 export const getStatusByMailToken = async ({
-  mailAuthToken, database, transaction
+  mailAuthToken, transaction
-}: { mailAuthToken: string, database: Database, transaction: Transaction }) => {
+}: { mailAuthToken: string, transaction: SimpleDatabaseTransaction }) => {
-  const mailInfo = await requireMailAndLocaleByAuthToken({ mailAuthToken, database, transaction, invalidate: false })
+  const mailInfo = await requireMailAndLocaleByAuthToken({ mailAuthToken, transaction, invalidate: false })
   const mail = mailInfo.mail
 
-  const status = await getStatusByMailAddress({ mail, database, transaction })
+  const status = await getStatusByMailAddress({ mail, transaction })
 
   return { mail, status }
 }

src/function/parent/link-mail-address.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -16,7 +16,7 @@
  */
 
 import { Conflict, Unauthorized } from 'http-errors'
-import { Database } from '../../database'
+import { SimpleDatabase } from '../../database/simple'
 import { generateVersionId } from '../../util/token'
 import { WebsocketApi } from '../../websocket'
 import { requireMailAndLocaleByAuthToken } from '../authentication'
@@ -27,16 +27,16 @@ export const linkMailAddress = async ({ mailAuthToken, deviceAuthToken, parentUs
   deviceAuthToken: string
   parentUserId: string
   parentPasswordSecondHash: string
-  database: Database
+  database: SimpleDatabase
   websocket: WebsocketApi
   // no transaction here because this is directly called from an API endpoint
 }) => {
   await database.transaction(async (transaction) => {
-    const deviceEntry = await database.device.findOne({
+    const deviceEntry = await transaction.legacy.database.device.findOne({
       where: {
         deviceAuthToken
       },
-      transaction
+      transaction: transaction.legacy.transaction
     })
 
     if (!deviceEntry) {
@@ -45,26 +45,26 @@ export const linkMailAddress = async ({ mailAuthToken, deviceAuthToken, parentUs
 
     const familyId = deviceEntry.familyId
 
-    const mailInfo = await requireMailAndLocaleByAuthToken({ mailAuthToken, database, transaction, invalidate: true })
+    const mailInfo = await requireMailAndLocaleByAuthToken({ mailAuthToken, transaction, invalidate: true })
 
-    const exisitingUser = await database.user.findOne({
+    const exisitingUser = await transaction.legacy.database.user.findOne({
       where: {
         mail: mailInfo.mail
       },
-      transaction
+      transaction: transaction.legacy.transaction
     })
 
     if (exisitingUser) {
       throw new Conflict()
     }
 
-    const parentEntry = await database.user.findOne({
+    const parentEntry = await transaction.legacy.database.user.findOne({
       where: {
         type: 'parent',
         familyId,
         userId: parentUserId
       },
-      transaction
+      transaction: transaction.legacy.transaction
     })
 
     if (!parentEntry) {
@@ -85,16 +85,16 @@ export const linkMailAddress = async ({ mailAuthToken, deviceAuthToken, parentUs
 
     parentEntry.mail = mailInfo.mail
 
-    await parentEntry.save({ transaction })
+    await parentEntry.save({ transaction: transaction.legacy.transaction })
 
     // invalidiate client caches
-    await database.family.update({
+    await transaction.legacy.database.family.update({
       userListVersion: generateVersionId()
     }, {
       where: {
         familyId
       },
-      transaction
+      transaction: transaction.legacy.transaction
     })
 
     // notify
@@ -103,9 +103,8 @@ export const linkMailAddress = async ({ mailAuthToken, deviceAuthToken, parentUs
       sourceDeviceId: null,
       generalLevel: 1,
       targetedLevels: new Map(),
-      database,
+      transaction,
-      websocket,
+      websocket
-      transaction
     })
   })
 }

src/function/parent/recover-parent-password.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -17,7 +17,7 @@
 
 import { Conflict } from 'http-errors'
 import { PlaintextParentPassword, assertPlaintextParentPasswordValid } from '../../api/schema'
-import { Database } from '../../database'
+import { SimpleDatabase } from '../../database/simple'
 import { sendPasswordRecoveryUsedMail } from '../../util/mail'
 import { generateVersionId } from '../../util/token'
 import { WebsocketApi } from '../../websocket'
@@ -25,7 +25,7 @@ import { requireMailAndLocaleByAuthToken } from '../authentication'
 import { notifyClientsAboutChangesDelayed } from '../websocket'
 
 export const recoverParentPassword = async ({ database, websocket, password, mailAuthToken }: {
-  database: Database
+  database: SimpleDatabase
   websocket: WebsocketApi
   password: PlaintextParentPassword
   mailAuthToken: string
@@ -34,14 +34,14 @@ export const recoverParentPassword = async ({ database, websocket, password, mai
   assertPlaintextParentPasswordValid(password)
 
   await database.transaction(async (transaction) => {
-    const mailInfo = await requireMailAndLocaleByAuthToken({ mailAuthToken, database, transaction, invalidate: true })
+    const mailInfo = await requireMailAndLocaleByAuthToken({ mailAuthToken, transaction, invalidate: true })
 
     // update the user entry
-    const userEntry = await database.user.findOne({
+    const userEntry = await transaction.legacy.database.user.findOne({
       where: {
         mail: mailInfo.mail
       },
-      transaction
+      transaction: transaction.legacy.transaction
     })
 
     if (!userEntry) {
@@ -52,29 +52,28 @@ export const recoverParentPassword = async ({ database, websocket, password, mai
     userEntry.secondPasswordHash = password.secondHash
     userEntry.secondPasswordSalt = password.secondSalt
 
-    await userEntry.save({ transaction })
+    await userEntry.save({ transaction: transaction.legacy.transaction })
 
     // invalidate the user list
-    await database.family.update({
+    await transaction.legacy.database.family.update({
       userListVersion: generateVersionId()
     }, {
       where: {
         familyId: userEntry.familyId
       },
-      transaction
+      transaction: transaction.legacy.transaction
     })
 
     await notifyClientsAboutChangesDelayed({
-      database,
+      transaction,
       familyId: userEntry.familyId,
       websocket,
       generalLevel: 2,
       targetedLevels: new Map(),
-      sourceDeviceId: null,
+      sourceDeviceId: null
-      transaction
     })
 
-    transaction.afterCommit(async () => {
+    transaction.enqueueAfterCommit(async () => {
       await sendPasswordRecoveryUsedMail({
         receiver: mailInfo.mail,
         locale: mailInfo.locale

src/function/parent/sign-in-into-family.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -17,7 +17,7 @@
 
 import { Conflict } from 'http-errors'
 import { NewDeviceInfo } from '../../api/schema'
-import { Database } from '../../database'
+import { SimpleDatabase } from '../../database/simple'
 import { sendDeviceLinkedMail } from '../../util/mail'
 import { generateAuthToken, generateIdWithinFamily, generateVersionId } from '../../util/token'
 import { WebsocketApi } from '../../websocket'
@@ -30,7 +30,7 @@ import { ServerDataStatus } from '../../object/serverdatastatus'
 import { createEmptyClientDataStatus } from '../../object/clientdatastatus'
 
 export const signInIntoFamily = async ({ database, eventHandler, mailAuthToken, newDeviceInfo, deviceName, websocket, clientLevel }: {
-  database: Database
+  database: SimpleDatabase
   eventHandler: EventHandler
   mailAuthToken: string
   newDeviceInfo: NewDeviceInfo
@@ -40,14 +40,14 @@ export const signInIntoFamily = async ({ database, eventHandler, mailAuthToken,
   // no transaction here because this is directly called from an API endpoint
 }): Promise<{ deviceId: string; deviceAuthToken: string; data: ServerDataStatus }> => {
   return database.transaction(async (transaction) => {
-    const mailInfo = await requireMailAndLocaleByAuthToken({ database, mailAuthToken, transaction, invalidate: true })
+    const mailInfo = await requireMailAndLocaleByAuthToken({ mailAuthToken, transaction, invalidate: true })
 
-    const userEntryUnsafe = await database.user.findOne({
+    const userEntryUnsafe = await transaction.legacy.database.user.findOne({
       where: {
         mail: mailInfo.mail
       },
       attributes: ['familyId', 'userId'],
-      transaction
+      transaction: transaction.legacy.transaction
     })
 
     if (!userEntryUnsafe) {
@@ -62,7 +62,7 @@ export const signInIntoFamily = async ({ database, eventHandler, mailAuthToken,
     const deviceAuthToken = generateAuthToken()
     const deviceId = generateIdWithinFamily()
 
-    await database.device.create(prepareDeviceEntry({
+    await transaction.legacy.database.device.create(prepareDeviceEntry({
       familyId: userEntry.familyId,
       deviceId,
       userId: userEntry.userId,
@@ -70,29 +70,28 @@ export const signInIntoFamily = async ({ database, eventHandler, mailAuthToken,
       deviceAuthToken,
       newDeviceInfo,
       isUserKeptSignedIn: true
-    }), { transaction })
+    }), { transaction: transaction.legacy.transaction })
 
     // notify about changes
-    await database.family.update({
+    await transaction.legacy.database.family.update({
       deviceListVersion: generateVersionId()
     }, {
       where: {
         familyId: userEntry.familyId
       },
-      transaction
+      transaction: transaction.legacy.transaction
     })
 
     await notifyClientsAboutChangesDelayed({
       familyId: userEntry.familyId,
       websocket,
-      database,
+      transaction,
       generalLevel: 1,
       targetedLevels: new Map(),
-      sourceDeviceId: deviceId,
+      sourceDeviceId: deviceId
-      transaction
     })
 
-    transaction.afterCommit(async () => {
+    transaction.enqueueAfterCommit(async () => {
       await sendDeviceLinkedMail({
         receiver: mailInfo.mail,
         locale: mailInfo.locale,
@@ -101,11 +100,10 @@ export const signInIntoFamily = async ({ database, eventHandler, mailAuthToken,
     })
 
     const data = await generateServerDataStatus({
-      database,
+      transaction,
       clientStatus: createEmptyClientDataStatus({ clientLevel }),
       familyId: userEntry.familyId,
       deviceId,
-      transaction,
       eventHandler
     })
 

src/function/purchase/add-purchase.ts

@@ -16,7 +16,7 @@
  */
 
 import { Conflict } from 'http-errors'
-import { Database, Transaction } from '../../database'
+import { SimpleDatabaseTransaction } from '../../database/simple'
 import { notifyClientsAboutChangesDelayed } from '../../function/websocket'
 import { WebsocketApi } from '../../websocket'
 
@@ -25,32 +25,31 @@ const week = day * 7
 const month = day * 31
 const year = day * 366
 
-export const addPurchase = async ({ database, familyId, type, service, transactionId, websocket, transaction }: {
+export const addPurchase = async ({ familyId, type, service, transactionId, websocket, transaction }: {
-  database: Database
+  transaction: SimpleDatabaseTransaction
   familyId: string
   type: 'month' | 'year' | 'unpaid14'
   service: 'googleplay' | 'directpurchase'
   transactionId: string
   websocket: WebsocketApi
-  transaction: Transaction
 }) => {
-  const oldPurchaseEntry = await database.purchase.findOne({
+  const oldPurchaseEntry = await transaction.legacy.database.purchase.findOne({
     where: {
       service,
       transactionId
     },
-    transaction
+    transaction: transaction.legacy.transaction
   })
 
   if (oldPurchaseEntry) {
     return
   }
 
-  const familyEntry = await database.family.findOne({
+  const familyEntry = await transaction.legacy.database.family.findOne({
     where: {
       familyId
     },
-    transaction
+    transaction: transaction.legacy.transaction
   })
 
   if (!familyEntry) {
@@ -95,9 +94,9 @@ export const addPurchase = async ({ database, familyId, type, service, transacti
     throw new Error()
   }
 
-  await familyEntry.save({ transaction })
+  await familyEntry.save({ transaction: transaction.legacy.transaction })
 
-  await database.purchase.create({
+  await transaction.legacy.database.purchase.create({
     familyId,
     service,
     transactionId,
@@ -106,16 +105,15 @@ export const addPurchase = async ({ database, familyId, type, service, transacti
     previousFullVersionEndTime,
     newFullVersionEndTime: familyEntry.fullVersionUntil
   }, {
-    transaction
+    transaction: transaction.legacy.transaction
   })
 
   await notifyClientsAboutChangesDelayed({
     familyId,
     sourceDeviceId: null,
-    database,
+    transaction,
     websocket,
     generalLevel: 2,
-    targetedLevels: new Map(),
+    targetedLevels: new Map()
-    transaction
   })
 }

src/function/purchase/require-family-entry.ts

@@ -16,19 +16,18 @@
  */
 
 import { InternalServerError, Unauthorized } from 'http-errors'
-import { Database, Transaction } from '../../database'
+import { SimpleDatabaseTransaction } from '../../database/simple'
 
-export const requireFamilyEntry = async ({ database, deviceAuthToken, transaction }: {
+export const requireFamilyEntry = async ({ transaction, deviceAuthToken }: {
-  database: Database
+  transaction: SimpleDatabaseTransaction
   deviceAuthToken: string
-  transaction: Transaction
 }) => {
-  const deviceEntryUnsafe = await database.device.findOne({
+  const deviceEntryUnsafe = await transaction.legacy.database.device.findOne({
     where: {
       deviceAuthToken
     },
     attributes: ['familyId'],
-    transaction
+    transaction: transaction.legacy.transaction
   })
 
   if (!deviceEntryUnsafe) {
@@ -39,12 +38,12 @@ export const requireFamilyEntry = async ({ database, deviceAuthToken, transactio
     familyId: deviceEntryUnsafe.familyId
   }
 
-  const familyEntryUnsafe = await database.family.findOne({
+  const familyEntryUnsafe = await transaction.legacy.database.family.findOne({
     where: {
       familyId: deviceEntry.familyId
     },
     attributes: ['fullVersionUntil', 'fullVersionDebts'],
-    transaction
+    transaction: transaction.legacy.transaction
   })
 
   if (!familyEntryUnsafe) {

src/function/statusmessage/index.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2020 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -15,37 +15,39 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-import * as Sequelize from 'sequelize'
+import { SimpleDatabase, SimpleDatabaseTransaction } from '../../database/simple'
-import { Database } from '../../database'
 import { configItemIds } from '../../database/config'
 
-export const getStatusMessage = async ({ database, transaction }: {
+export const getStatusMessage = async ({ transaction }: {
-  database: Database
+  transaction: SimpleDatabaseTransaction
-  transaction?: Sequelize.Transaction
 }) => {
-  const currentStatusMessageItem = await database.config.findByPk(configItemIds.statusMessage, { transaction })
+  const currentStatusMessageItem = await transaction.legacy.database.config.findByPk(
+    configItemIds.statusMessage,
+    { transaction: transaction.legacy.transaction }
+  )
+
   const currentStatusMessage = (currentStatusMessageItem ? currentStatusMessageItem.value : null) || ''
 
   return currentStatusMessage
 }
 
 export const setStatusMessage = async ({ database, newStatusMessage }: {
-  database: Database
+  database: SimpleDatabase
   newStatusMessage: string
 }) => {
   await database.transaction(async (transaction) => {
     if (newStatusMessage === '') {
-      await database.config.destroy({
+      await transaction.legacy.database.config.destroy({
         where: {
           id: configItemIds.statusMessage
         },
-        transaction
+        transaction: transaction.legacy.transaction
       })
     } else {
-      await database.config.upsert({
+      await transaction.legacy.database.config.upsert({
         id: configItemIds.statusMessage,
         value: newStatusMessage
-      }, { transaction })
+      }, { transaction: transaction.legacy.transaction })
     }
   })
 }

src/function/sync/apply-actions/baseinfo.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2020 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -16,7 +16,7 @@
  */
 
 import { Unauthorized } from 'http-errors'
-import { Database, Transaction } from '../../../database'
+import { SimpleDatabaseTransaction } from '../../../database/simple'
 import { SourceFamilyNotFoundException } from './exception/illegal-state'
 
 export interface ApplyActionBaseInfo {
@@ -26,15 +26,14 @@ export interface ApplyActionBaseInfo {
   hasFullVersion: boolean
 }
 
-export async function getApplyActionBaseInfo ({ database, transaction, deviceAuthToken }: {
+export async function getApplyActionBaseInfo ({ transaction, deviceAuthToken }: {
-  database: Database
+  transaction: SimpleDatabaseTransaction
-  transaction: Transaction
   deviceAuthToken: string
 }): Promise<ApplyActionBaseInfo> {
-  const deviceEntryUnsafe = await database.device.findOne({
+  const deviceEntryUnsafe = await transaction.legacy.database.device.findOne({
     where: { deviceAuthToken },
     attributes: ['familyId', 'deviceId', 'nextSequenceNumber'],
-    transaction
+    transaction: transaction.legacy.transaction
   })
 
   if (!deviceEntryUnsafe) {
@@ -47,11 +46,11 @@ export async function getApplyActionBaseInfo ({ database, transaction, deviceAut
     nextSequenceNumber: deviceEntryUnsafe.nextSequenceNumber
   }
 
-  const familyEntryUnsafe = await database.family.findOne({
+  const familyEntryUnsafe = await transaction.legacy.database.family.findOne({
     where: {
       familyId: deviceEntry.familyId
     },
-    transaction,
+    transaction: transaction.legacy.transaction,
     attributes: ['hasFullVersion']
   })
 

src/function/sync/apply-actions/cache.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -19,7 +19,7 @@ import { memoize } from 'lodash'
 import * as Sequelize from 'sequelize'
 import { config } from '../../../config'
 import { VisibleConnectedDevicesManager } from '../../../connected-devices'
-import { Database } from '../../../database'
+import { SimpleDatabaseTransaction } from '../../../database/simple'
 import { setToList } from '../../../util/list'
 import { generateVersionId } from '../../../util/token'
 import { SourceUserNotFoundException } from './exception/illegal-state'
@@ -29,8 +29,7 @@ export class Cache {
   readonly familyId: string
   readonly deviceId: string
   readonly hasFullVersion: boolean
-  transaction: Sequelize.Transaction
+  transaction: SimpleDatabaseTransaction
-  readonly database: Database
   readonly connectedDevicesManager: VisibleConnectedDevicesManager
   private requireSenderDoFullSync = false
 
@@ -48,18 +47,16 @@ export class Cache {
   triggeredSyncLevel: 0 | 1 | 2 = 0 // 0 = no, 1 = unimportant, 2 = important
   targetedTriggeredSyncLevels = new Map<string, 0 | 1 | 2>()
 
-  constructor ({ familyId, deviceId, hasFullVersion, database, transaction, connectedDevicesManager }: {
+  constructor ({ familyId, deviceId, hasFullVersion, transaction, connectedDevicesManager }: {
     familyId: string
     deviceId: string
     hasFullVersion: boolean
-    database: Database
+    transaction: SimpleDatabaseTransaction
-    transaction: Sequelize.Transaction
     connectedDevicesManager: VisibleConnectedDevicesManager
   }) {
     this.familyId = familyId
     this.deviceId = deviceId
     this.hasFullVersion = hasFullVersion || config.alwaysPro
-    this.database = database
     this.transaction = transaction
     this.connectedDevicesManager = connectedDevicesManager
   }
@@ -77,7 +74,7 @@ export class Cache {
   async subtransaction<T> (callback: () => Promise<T>): Promise<T> {
     const oldTransaction = this.transaction
 
-    return this.database.transaction(async (newTransaction) => {
+    return this.transaction.transaction(async (newTransaction) => {
       try {
         this.transaction = newTransaction
 
@@ -87,18 +84,18 @@ export class Cache {
       } finally {
         this.transaction = oldTransaction
       }
-    }, { transaction: oldTransaction })
+    })
   }
 
   getSecondPasswordHashOfParent = memoize(async (parentId: string) => {
-    const userEntryUnsafe = await this.database.user.findOne({
+    const userEntryUnsafe = await this.transaction.legacy.database.user.findOne({
       where: {
         familyId: this.familyId,
         userId: parentId,
         type: 'parent'
       },
       attributes: ['secondPasswordHash'],
-      transaction: this.transaction
+      transaction: this.transaction.legacy.transaction
     })
 
     if (!userEntryUnsafe) {
@@ -109,14 +106,14 @@ export class Cache {
   })
 
   getSecondPasswordHashOfChild = memoize(async (childId: string) => {
-    const userEntryUnsafe = await this.database.user.findOne({
+    const userEntryUnsafe = await this.transaction.legacy.database.user.findOne({
       where: {
         familyId: this.familyId,
         userId: childId,
         type: 'child'
       },
       attributes: ['secondPasswordHash'],
-      transaction: this.transaction
+      transaction: this.transaction.legacy.transaction
     })
 
     if (!userEntryUnsafe) {
@@ -131,24 +128,24 @@ export class Cache {
   })
 
   doesCategoryExist = memoize(async (categoryId: string) => {
-    const categoryEntry = await this.database.category.findOne({
+    const categoryEntry = await this.transaction.legacy.database.category.findOne({
       where: {
         familyId: this.familyId,
         categoryId
       },
-      transaction: this.transaction
+      transaction: this.transaction.legacy.transaction
     })
 
     return !!categoryEntry
   })
 
   doesUserExist = memoize(async (userId: string) => {
-    const userEntry = await this.database.user.findOne({
+    const userEntry = await this.transaction.legacy.database.user.findOne({
       where: {
         familyId: this.familyId,
         userId
       },
-      transaction: this.transaction
+      transaction: this.transaction.legacy.transaction
     })
 
     return !!userEntry
@@ -158,10 +155,10 @@ export class Cache {
   requireSenderFullSync: () => void = () => this.requireSenderDoFullSync = true
 
   async saveModifiedVersionNumbers () {
-    const { database, transaction, familyId } = this
+    const { familyId } = this
 
     if (this.categoriesWithModifiedApps.size > 0) {
-      await database.category.update({
+      await this.transaction.legacy.database.category.update({
         assignedAppsVersion: generateVersionId()
       }, {
         where: {
@@ -170,14 +167,14 @@ export class Cache {
             [Sequelize.Op.in]: setToList(this.categoriesWithModifiedApps)
           }
         },
-        transaction
+        transaction: this.transaction.legacy.transaction
       })
 
       this.categoriesWithModifiedApps.clear()
     }
 
     if (this.categoriesWithModifiedBaseData.size > 0) {
-      await database.category.update({
+      await this.transaction.legacy.database.category.update({
         baseVersion: generateVersionId()
       }, {
         where: {
@@ -186,14 +183,14 @@ export class Cache {
             [Sequelize.Op.in]: setToList(this.categoriesWithModifiedBaseData)
           }
         },
-        transaction
+        transaction: this.transaction.legacy.transaction
       })
 
       this.categoriesWithModifiedBaseData.clear()
     }
 
     if (this.categoriesWithModifiedTimeLimitRules.size > 0) {
-      await database.category.update({
+      await this.transaction.legacy.database.category.update({
         timeLimitRulesVersion: generateVersionId()
       }, {
         where: {
@@ -202,14 +199,14 @@ export class Cache {
             [Sequelize.Op.in]: setToList(this.categoriesWithModifiedTimeLimitRules)
           }
         },
-        transaction
+        transaction: this.transaction.legacy.transaction
       })
 
       this.categoriesWithModifiedTimeLimitRules.clear()
     }
 
     if (this.categoriesWithModifiedUsedTimes.size > 0) {
-      await database.category.update({
+      await this.transaction.legacy.database.category.update({
         usedTimesVersion: generateVersionId()
       }, {
         where: {
@@ -218,14 +215,14 @@ export class Cache {
             [Sequelize.Op.in]: setToList(this.categoriesWithModifiedUsedTimes)
           }
         },
-        transaction
+        transaction: this.transaction.legacy.transaction
       })
 
       this.categoriesWithModifiedUsedTimes.clear()
     }
 
     if (this.categoriesWithModifiedTasks.size > 0) {
-      await database.category.update({
+      await this.transaction.legacy.database.category.update({
         taskListVersion: generateVersionId()
       }, {
         where: {
@@ -234,46 +231,46 @@ export class Cache {
             [Sequelize.Op.in]: setToList(this.categoriesWithModifiedTasks)
           }
         },
-        transaction
+        transaction: this.transaction.legacy.transaction
       })
 
       this.categoriesWithModifiedUsedTimes.clear()
     }
 
     if (this.invalidiateUserList) {
-      await database.family.update({
+      await this.transaction.legacy.database.family.update({
         userListVersion: generateVersionId()
       }, {
         where: {
           familyId: this.familyId
         },
-        transaction
+        transaction: this.transaction.legacy.transaction
       })
 
       this.invalidiateUserList = false
     }
 
     if (this.invalidiateDeviceList) {
-      await database.family.update({
+      await this.transaction.legacy.database.family.update({
         deviceListVersion: generateVersionId()
       }, {
         where: {
           familyId: this.familyId
         },
-        transaction
+        transaction: this.transaction.legacy.transaction
       })
 
       this.invalidiateDeviceList = false
     }
 
     if (this.invalidateU2fList) {
-      await database.family.update({
+      await this.transaction.legacy.database.family.update({
         u2fKeysVersion: generateVersionId()
       }, {
         where: {
           familyId: this.familyId
         },
-        transaction
+        transaction: this.transaction.legacy.transaction
       })
 
       this.invalidateU2fList = false

src/function/sync/apply-actions/dispatch-app-logic-action/addusedtime.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -37,12 +37,12 @@ export async function dispatchAddUsedTime ({ action, cache }: {
 }) {
   const roundedTimestamp = getRoundedTimestamp().toString(10)
 
-  const categoryEntryUnsafe = await cache.database.category.findOne({
+  const categoryEntryUnsafe = await cache.transaction.legacy.database.category.findOne({
     where: {
       familyId: cache.familyId,
       categoryId: action.categoryId
     },
-    transaction: cache.transaction,
+    transaction: cache.transaction.legacy.transaction,
     attributes: [
       'childId',
       'parentCategoryId',
@@ -65,7 +65,7 @@ export async function dispatchAddUsedTime ({ action, cache }: {
     currentExtraTime: number
   }) => {
     if (action.timeToAdd !== 0) {
-      const oldItem = await cache.database.usedTime.findOne({
+      const oldItem = await cache.transaction.legacy.database.usedTime.findOne({
         where: {
           familyId: cache.familyId,
           categoryId: action.categoryId,
@@ -73,7 +73,7 @@ export async function dispatchAddUsedTime ({ action, cache }: {
           startMinuteOfDay: MinuteOfDay.MIN,
           endMinuteOfDay: MinuteOfDay.MAX
         },
-        transaction: cache.transaction
+        transaction: cache.transaction.legacy.transaction
       })
 
       if (oldItem) {
@@ -84,7 +84,7 @@ export async function dispatchAddUsedTime ({ action, cache }: {
         const newLastUpdate = parseInt(roundedTimestamp, 10)
 
         if (oldUsedTime !== newUsedTime || oldLastUpdate !== newLastUpdate) {
-          const [updatedRows] = await cache.database.usedTime.update({
+          const [updatedRows] = await cache.transaction.legacy.database.usedTime.update({
             usedTime: newUsedTime,
             lastUpdate: newLastUpdate.toString(10)
           }, {
@@ -95,7 +95,7 @@ export async function dispatchAddUsedTime ({ action, cache }: {
               startMinuteOfDay: MinuteOfDay.MIN,
               endMinuteOfDay: MinuteOfDay.MAX
             },
-            transaction: cache.transaction
+            transaction: cache.transaction.legacy.transaction
           })
 
           if (updatedRows === 0) {
@@ -103,7 +103,7 @@ export async function dispatchAddUsedTime ({ action, cache }: {
           }
         }
       } else {
-        await cache.database.usedTime.create({
+        await cache.transaction.legacy.database.usedTime.create({
           familyId: cache.familyId,
           categoryId: action.categoryId,
           dayOfEpoch: action.dayOfEpoch,
@@ -112,20 +112,20 @@ export async function dispatchAddUsedTime ({ action, cache }: {
           startMinuteOfDay: MinuteOfDay.MIN,
           endMinuteOfDay: MinuteOfDay.MAX
         }, {
-          transaction: cache.transaction
+          transaction: cache.transaction.legacy.transaction
         })
       }
     }
 
     if (action.extraTimeToSubtract !== 0) {
-      await cache.database.category.update({
+      await cache.transaction.legacy.database.category.update({
         extraTimeInMillis: Math.max(0, currentExtraTime - action.extraTimeToSubtract)
       }, {
         where: {
           familyId: cache.familyId,
           categoryId: categoryId
         },
-        transaction: cache.transaction
+        transaction: cache.transaction.legacy.transaction
       })
 
       cache.categoriesWithModifiedBaseData.add(categoryId)
@@ -140,13 +140,13 @@ export async function dispatchAddUsedTime ({ action, cache }: {
   })
 
   if (categoryEntry.parentCategoryId !== '') {
-    const parentCategoryEntry = await cache.database.category.findOne({
+    const parentCategoryEntry = await cache.transaction.legacy.database.category.findOne({
       where: {
         familyId: cache.familyId,
         categoryId: categoryEntry.parentCategoryId,
         childId: categoryEntry.childId
       },
-      transaction: cache.transaction
+      transaction: cache.transaction.legacy.transaction
     })
 
     if (parentCategoryEntry) {

src/function/sync/apply-actions/dispatch-app-logic-action/addusedtime2.ts

@@ -37,13 +37,13 @@ export async function dispatchAddUsedTimeVersion2 ({ deviceId, action, cache, ev
   cache: Cache
   eventHandler: EventHandler
 }) {
-  const deviceEntryUnsafe = await cache.database.device.findOne({
+  const deviceEntryUnsafe = await cache.transaction.legacy.database.device.findOne({
     where: {
       familyId: cache.familyId,
       deviceId: deviceId
     },
     attributes: ['currentUserId'],
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (!deviceEntryUnsafe) {
@@ -60,12 +60,12 @@ export async function dispatchAddUsedTimeVersion2 ({ deviceId, action, cache, ev
   let addUsedTimeForADifferentUserThanTheCurrentUserOfTheDevice = false
 
   for (const item of action.items) {
-    const categoryEntryUnsafe = await cache.database.category.findOne({
+    const categoryEntryUnsafe = await cache.transaction.legacy.database.category.findOne({
       where: {
         familyId: cache.familyId,
         categoryId: item.categoryId
       },
-      transaction: cache.transaction,
+      transaction: cache.transaction.legacy.transaction,
       attributes: [
         'childId',
         'extraTimeInMillis'
@@ -93,7 +93,7 @@ export async function dispatchAddUsedTimeVersion2 ({ deviceId, action, cache, ev
       const lengthInMinutes = (end - start) + 1
       const lengthInMs = lengthInMinutes * 1000 * 60
 
-      const oldItem = await cache.database.usedTime.findOne({
+      const oldItem = await cache.transaction.legacy.database.usedTime.findOne({
         where: {
           familyId: cache.familyId,
           categoryId: item.categoryId,
@@ -101,7 +101,7 @@ export async function dispatchAddUsedTimeVersion2 ({ deviceId, action, cache, ev
           startMinuteOfDay: start,
           endMinuteOfDay: end
         },
-        transaction: cache.transaction
+        transaction: cache.transaction.legacy.transaction
       })
 
       if (oldItem) {
@@ -112,7 +112,7 @@ export async function dispatchAddUsedTimeVersion2 ({ deviceId, action, cache, ev
         const newLastUpdate = parseInt(roundedTimestampForUsedTime, 10)
 
         if (oldUsedTime !== newUsedTime || oldLastUpdate !== newLastUpdate) {
-          const [updatedRows] = await cache.database.usedTime.update({
+          const [updatedRows] = await cache.transaction.legacy.database.usedTime.update({
             usedTime: newUsedTime,
             lastUpdate: newLastUpdate.toString(10)
           }, {
@@ -123,7 +123,7 @@ export async function dispatchAddUsedTimeVersion2 ({ deviceId, action, cache, ev
               startMinuteOfDay: start,
               endMinuteOfDay: end
             },
-            transaction: cache.transaction
+            transaction: cache.transaction.legacy.transaction
           })
 
           if (updatedRows === 0) {
@@ -131,7 +131,7 @@ export async function dispatchAddUsedTimeVersion2 ({ deviceId, action, cache, ev
           }
         }
       } else {
-        const oldTime: number | null = await cache.database.usedTime.aggregate(
+        const oldTime: number | null = await cache.transaction.legacy.database.usedTime.aggregate(
           'usedTime',
           'MAX',
           {
@@ -146,13 +146,13 @@ export async function dispatchAddUsedTimeVersion2 ({ deviceId, action, cache, ev
                 [Sequelize.Op.lte]: end
               }
             },
-            transaction: cache.transaction
+            transaction: cache.transaction.legacy.transaction
           }
         ) || 0
 
         if (oldTime !== null && typeof oldTime !== 'number') throw new Error()
 
-        await cache.database.usedTime.create({
+        await cache.transaction.legacy.database.usedTime.create({
           familyId: cache.familyId,
           categoryId: item.categoryId,
           dayOfEpoch: action.dayOfEpoch,
@@ -161,7 +161,7 @@ export async function dispatchAddUsedTimeVersion2 ({ deviceId, action, cache, ev
           startMinuteOfDay: start,
           endMinuteOfDay: end
         }, {
-          transaction: cache.transaction
+          transaction: cache.transaction.legacy.transaction
         })
       }
     }
@@ -179,7 +179,7 @@ export async function dispatchAddUsedTimeVersion2 ({ deviceId, action, cache, ev
     for (let j = 0; j < item.sessionDurationLimits.length; j++) {
       const limit = item.sessionDurationLimits[j]
 
-      const oldItem = await cache.database.sessionDuration.findOne({
+      const oldItem = await cache.transaction.legacy.database.sessionDuration.findOne({
         where: {
           familyId: cache.familyId,
           categoryId: item.categoryId,
@@ -188,11 +188,11 @@ export async function dispatchAddUsedTimeVersion2 ({ deviceId, action, cache, ev
           startMinuteOfDay: limit.start,
           endMinuteOfDay: limit.end
         },
-        transaction: cache.transaction
+        transaction: cache.transaction.legacy.transaction
       })
 
       const oldDuration: () => Promise<number> = async () => {
-        const fittingDurationItems = await cache.database.sessionDuration.findAll({
+        const fittingDurationItems = await cache.transaction.legacy.database.sessionDuration.findAll({
           where: {
             familyId: cache.familyId,
             categoryId: item.categoryId,
@@ -209,7 +209,7 @@ export async function dispatchAddUsedTimeVersion2 ({ deviceId, action, cache, ev
               [Sequelize.Op.lte]: limit.pause
             }
           },
-          transaction: cache.transaction
+          transaction: cache.transaction.legacy.transaction
         })
 
         const fittingDurationItemsLastUsageFiltered =
@@ -259,9 +259,9 @@ export async function dispatchAddUsedTimeVersion2 ({ deviceId, action, cache, ev
           }
         }
 
-        await oldItem.save({ transaction: cache.transaction })
+        await oldItem.save({ transaction: cache.transaction.legacy.transaction })
       } else {
-        await cache.database.sessionDuration.create({
+        await cache.transaction.legacy.database.sessionDuration.create({
           familyId: cache.familyId,
           categoryId: item.categoryId,
           maxSessionDuration: limit.duration,
@@ -272,21 +272,21 @@ export async function dispatchAddUsedTimeVersion2 ({ deviceId, action, cache, ev
           lastUsage: action.trustedTimestamp.toString(10),
           lastSessionDuration: await oldDuration() + item.timeToAdd,
           roundedLastUpdate: roundedTimestampForSessionDuration
-        }, { transaction: cache.transaction })
+        }, { transaction: cache.transaction.legacy.transaction })
       }
     }
 
     cache.categoriesWithModifiedUsedTimes.add(item.categoryId)
 
     if (item.extraTimeToSubtract !== 0) {
-      await cache.database.category.update({
+      await cache.transaction.legacy.database.category.update({
         extraTimeInMillis: Math.max(0, categoryEntry.extraTimeInMillis - item.extraTimeToSubtract)
       }, {
         where: {
           familyId: cache.familyId,
           categoryId: item.categoryId
         },
-        transaction: cache.transaction
+        transaction: cache.transaction.legacy.transaction
       })
 
       cache.categoriesWithModifiedBaseData.add(item.categoryId)

src/function/sync/apply-actions/dispatch-app-logic-action/finishkeyrequest.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -23,13 +23,13 @@ export async function dispatchFinishKeyRequestAction ({ action, cache, deviceId
   action: FinishKeyRequestAction
   cache: Cache
 }) {
-  await cache.database.keyRequest.destroy({
+  await cache.transaction.legacy.database.keyRequest.destroy({
     where: {
       familyId: cache.familyId,
       senderDeviceId: deviceId,
       senderSequenceNumber: action.deviceSequenceNumber.toString(10)
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   // no sync triggered

src/function/sync/apply-actions/dispatch-app-logic-action/marktaskpendingaction.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -26,12 +26,12 @@ export async function dispatchMarkTaskPendingAction ({ action, cache, deviceId }
   action: MarkTaskPendingAction
   cache: Cache
 }) {
-  const taskInfoUnsafe = await cache.database.childTask.findOne({
+  const taskInfoUnsafe = await cache.transaction.legacy.database.childTask.findOne({
     where: {
       familyId: cache.familyId,
       taskId: action.taskId
     },
-    transaction: cache.transaction,
+    transaction: cache.transaction.legacy.transaction,
     attributes: ['categoryId', 'pendingRequest', 'taskTitle']
   })
 
@@ -45,13 +45,13 @@ export async function dispatchMarkTaskPendingAction ({ action, cache, deviceId }
 
   if (taskInfo.pendingRequest !== 0) return // review already requested
 
-  const categoryInfoUnsafe = await cache.database.category.findOne({
+  const categoryInfoUnsafe = await cache.transaction.legacy.database.category.findOne({
     where: {
       familyId: cache.familyId,
       categoryId: taskInfo.categoryId
     },
     attributes: ['childId'],
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (categoryInfoUnsafe === null) {
@@ -60,13 +60,13 @@ export async function dispatchMarkTaskPendingAction ({ action, cache, deviceId }
 
   const categoryInfo = { childId: categoryInfoUnsafe.childId }
 
-  const deviceInfoUnsafe = await cache.database.device.findOne({
+  const deviceInfoUnsafe = await cache.transaction.legacy.database.device.findOne({
     where: {
       familyId: cache.familyId,
       deviceId
     },
     attributes: ['currentUserId'],
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (deviceInfoUnsafe === null) throw new SourceDeviceNotFoundException()
@@ -77,33 +77,33 @@ export async function dispatchMarkTaskPendingAction ({ action, cache, deviceId }
     throw new IllegalStateException({ staticMessage: 'Can not mark task pending for other user than the current user' })
   }
 
-  const childInfoUnsafe = await cache.database.user.findOne({
+  const childInfoUnsafe = await cache.transaction.legacy.database.user.findOne({
     where: {
       familyId: cache.familyId,
       userId: categoryInfo.childId
     },
     attributes: ['name'],
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (childInfoUnsafe === null) throw new SourceUserNotFoundException()
 
   const childInfo = { name: childInfoUnsafe.name }
 
-  await cache.database.childTask.update({ pendingRequest: 1 }, {
+  await cache.transaction.legacy.database.childTask.update({ pendingRequest: 1 }, {
     where: {
       familyId: cache.familyId,
       taskId: action.taskId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   cache.categoriesWithModifiedTasks.add(taskInfo.categoryId)
   cache.incrementTriggeredSyncLevel(1) // parents are not faster reachable
 
   await sendTaskDoneMails({
-    database: cache.database,
+    database: cache.transaction.legacy.database,
-    transaction: cache.transaction,
+    transaction: cache.transaction.legacy.transaction,
     familyId: cache.familyId,
     childName: childInfo.name,
     taskTitle: taskInfo.taskTitle

src/function/sync/apply-actions/dispatch-app-logic-action/ping.ts

@@ -33,25 +33,25 @@ export async function dispatchPingAction ({ action, cache, deviceId }: {
     else throw new Error()
 
     // delete any previous ping/pong
-    await cache.database.ping.destroy({
+    await cache.transaction.legacy.database.ping.destroy({
       where: {
         familyId: cache.familyId,
         receiverDeviceId: action.deviceId,
         senderDeviceId: deviceId,
 	type: type
       },
-      transaction: cache.transaction
+      transaction: cache.transaction.legacy.transaction
     })
 
     // insert
-    await cache.database.ping.create({
+    await cache.transaction.legacy.database.ping.create({
       familyId: cache.familyId,
       receiverDeviceId: action.deviceId,
       senderDeviceId: deviceId,
       type,
       token: action.token
     }, {
-      transaction: cache.transaction
+      transaction: cache.transaction.legacy.transaction
     })
 
     // notify
@@ -60,14 +60,14 @@ export async function dispatchPingAction ({ action, cache, deviceId }: {
 
   // handle deleting
   if (action.event === 'pong' || action.event === 'clear') {
-    await cache.database.ping.destroy({
+    await cache.transaction.legacy.database.ping.destroy({
       where: {
         familyId: cache.familyId,
         receiverDeviceId: deviceId,
         senderDeviceId: action.deviceId,
         token: action.token
       },
-      transaction: cache.transaction
+      transaction: cache.transaction.legacy.transaction
     })
   }
 }

src/function/sync/apply-actions/dispatch-app-logic-action/replytokeyrequest.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -26,13 +26,13 @@ export async function dispatchReplyToKeyRequestAction ({ deviceId, action, cache
   cache: Cache
   eventHandler: EventHandler
 }) {
-  const requestUnsafe = await cache.database.keyRequest.findOne({
+  const requestUnsafe = await cache.transaction.legacy.database.keyRequest.findOne({
     where: {
       familyId: cache.familyId,
       serverSequenceNumber: action.requestServerSequenceNumber.toString(10)
     },
     attributes: ['senderDeviceId', 'senderSequenceNumber'],
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (!requestUnsafe) {
@@ -46,14 +46,14 @@ export async function dispatchReplyToKeyRequestAction ({ deviceId, action, cache
     senderSequenceNumber: requestUnsafe.senderSequenceNumber
   }
 
-  const oldReplyCounter = await cache.database.keyResponse.count({
+  const oldReplyCounter = await cache.transaction.legacy.database.keyResponse.count({
     where: {
       familyId: cache.familyId,
       receiverDeviceId: request.senderDeviceId,
       requestServerSequenceNumber: action.requestServerSequenceNumber.toString(10),
       senderDeviceId: deviceId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (oldReplyCounter !== 0) {
@@ -62,12 +62,12 @@ export async function dispatchReplyToKeyRequestAction ({ deviceId, action, cache
     return
   }
 
-  const deviceEntryUnsafe = await cache.database.device.findOne({
+  const deviceEntryUnsafe = await cache.transaction.legacy.database.device.findOne({
     where: {
       familyId: cache.familyId,
       deviceId: request.senderDeviceId
     },
-    transaction: cache.transaction,
+    transaction: cache.transaction.legacy.transaction,
     attributes: ['nextKeyReplySequenceNumber']
   })
 
@@ -81,17 +81,17 @@ export async function dispatchReplyToKeyRequestAction ({ deviceId, action, cache
     nextKeyReplySequenceNumber: deviceEntryUnsafe.nextKeyReplySequenceNumber
   }
 
-  await cache.database.device.update({
+  await cache.transaction.legacy.database.device.update({
     nextKeyReplySequenceNumber: (parseInt(deviceEntry.nextKeyReplySequenceNumber) + 1).toString(10)
   }, {
     where: {
       familyId: cache.familyId,
       deviceId: request.senderDeviceId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
-  await cache.database.keyResponse.create({
+  await cache.transaction.legacy.database.keyResponse.create({
     familyId: cache.familyId,
     receiverDeviceId: request.senderDeviceId,
     requestServerSequenceNumber: action.requestServerSequenceNumber.toString(10),
@@ -102,7 +102,7 @@ export async function dispatchReplyToKeyRequestAction ({ deviceId, action, cache
     encryptedKey: action.encryptedKey,
     signature: action.signature
   }, {
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   cache.incrementTargetedTriggeredSyncLevel(request.senderDeviceId, 2)

src/function/sync/apply-actions/dispatch-app-logic-action/sendkeyrequest.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -24,11 +24,11 @@ export async function dispatchSendKeyRequestAction ({ action, cache, deviceId }:
   action: SendKeyRequestAction
   cache: Cache
 }) {
-  const familyEntryUnsafe = await cache.database.family.findOne({
+  const familyEntryUnsafe = await cache.transaction.legacy.database.family.findOne({
     where: {
       familyId: cache.familyId
     },
-    transaction: cache.transaction,
+    transaction: cache.transaction.legacy.transaction,
     attributes: ['nextServerKeyRequestSeq']
   })
 
@@ -38,16 +38,16 @@ export async function dispatchSendKeyRequestAction ({ action, cache, deviceId }:
 
   const serverSequenceNumber = familyEntryUnsafe.nextServerKeyRequestSeq
 
-  await cache.database.family.update({
+  await cache.transaction.legacy.database.family.update({
     nextServerKeyRequestSeq: (parseInt(serverSequenceNumber, 10) + 1).toString(10)
   }, {
     where: {
       familyId: cache.familyId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
-  await cache.database.keyRequest.destroy({
+  await cache.transaction.legacy.database.keyRequest.destroy({
     where: {
       familyId: cache.familyId,
       senderDeviceId: deviceId,
@@ -55,10 +55,10 @@ export async function dispatchSendKeyRequestAction ({ action, cache, deviceId }:
       deviceId: action.deviceId || null,
       categoryId: action.categoryId || null
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
-  await cache.database.keyRequest.create({
+  await cache.transaction.legacy.database.keyRequest.create({
     familyId: cache.familyId,
     serverSequenceNumber: serverSequenceNumber,
     senderDeviceId: deviceId,
@@ -69,7 +69,7 @@ export async function dispatchSendKeyRequestAction ({ action, cache, deviceId }:
     tempKey: action.tempKey,
     signature: action.signature
   }, {
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   cache.incrementTriggeredSyncLevel(2)

src/function/sync/apply-actions/dispatch-app-logic-action/signoutatdevice.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -30,12 +30,12 @@ export async function dispatchSignOutAtDevice ({ deviceId, cache }: {
     throw new PremiumVersionMissingException()
   }
 
-  const deviceEntry = await cache.database.device.findOne({
+  const deviceEntry = await cache.transaction.legacy.database.device.findOne({
     where: {
       familyId: cache.familyId,
       deviceId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (!deviceEntry) {

src/function/sync/apply-actions/dispatch-app-logic-action/trieddisablingdeviceadmin.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -26,12 +26,12 @@ export async function dispatchTriedDisablingDeviceAdmin ({ deviceId, cache }: {
   action: TriedDisablingDeviceAdminAction
   cache: Cache
 }) {
-  const deviceEntry = await cache.database.device.findOne({
+  const deviceEntry = await cache.transaction.legacy.database.device.findOne({
     where: {
       familyId: cache.familyId,
       deviceId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (deviceEntry === null) {
@@ -43,7 +43,7 @@ export async function dispatchTriedDisablingDeviceAdmin ({ deviceId, cache }: {
   if (!deviceEntry.triedDisablingDeviceAdmin) {
     deviceEntry.triedDisablingDeviceAdmin = true
 
-    await deviceEntry.save({ transaction: cache.transaction })
+    await deviceEntry.save({ transaction: cache.transaction.legacy.transaction })
 
     cache.invalidiateDeviceList = true
     cache.incrementTriggeredSyncLevel(1)
@@ -51,7 +51,6 @@ export async function dispatchTriedDisablingDeviceAdmin ({ deviceId, cache }: {
 
   if (!hadManipulationBefore) {
     await sendManipulationWarnings({
-      database: cache.database,
       transaction: cache.transaction,
       deviceName: deviceEntry.name,
       familyId: cache.familyId

src/function/sync/apply-actions/dispatch-app-logic-action/updatedevicestatus.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2023 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -30,12 +30,12 @@ export async function dispatchUpdateDeviceStatus ({ deviceId, action, cache }: {
   action: UpdateDeviceStatusAction
   cache: Cache
 }) {
-  const deviceEntry = await cache.database.device.findOne({
+  const deviceEntry = await cache.transaction.legacy.database.device.findOne({
     where: {
       familyId: cache.familyId,
       deviceId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (!deviceEntry) {
@@ -175,12 +175,11 @@ export async function dispatchUpdateDeviceStatus ({ deviceId, action, cache }: {
     }
   }
 
-  await deviceEntry.save({ transaction: cache.transaction })
+  await deviceEntry.save({ transaction: cache.transaction.legacy.transaction })
 
   if (hasDeviceManipulation(deviceEntry)) {
     if (!hadManipulationBefore) {
       await sendManipulationWarnings({
-        database: cache.database,
         transaction: cache.transaction,
         deviceName: deviceEntry.name,
         familyId: cache.familyId

src/function/sync/apply-actions/dispatch-app-logic-action/updateinstalledapps.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -26,13 +26,13 @@ export async function dispatchUpdateInstalledApps ({ deviceId, action, cache }:
   cache: Cache
 }) {
   async function upsert({ type, data }: { type: number, data: Buffer }) {
-    await cache.database.encryptedAppList.upsert({
+    await cache.transaction.legacy.database.encryptedAppList.upsert({
       familyId: cache.familyId,
       deviceId,
       type,
       version: generateVersionId(),
       data
-    }, { transaction: cache.transaction })
+    }, { transaction: cache.transaction.legacy.transaction })
   }
 
   if (action.base) {

src/function/sync/apply-actions/dispatch-app-logic-action/uploaddevicepublickey.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -26,12 +26,12 @@ export async function dispatchUploadDevicePublicKeyAction ({ deviceId, action, c
   cache: Cache
   eventHandler: EventHandler
 }) {
-  const deviceEntry = await cache.database.device.findOne({
+  const deviceEntry = await cache.transaction.legacy.database.device.findOne({
     where: {
       familyId: cache.familyId,
       deviceId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (deviceEntry === null) {
@@ -39,7 +39,7 @@ export async function dispatchUploadDevicePublicKeyAction ({ deviceId, action, c
   } else if (deviceEntry.publicKey === null) {
     deviceEntry.publicKey = action.key
 
-    await deviceEntry.save({ transaction: cache.transaction })
+    await deviceEntry.save({ transaction: cache.transaction.legacy.transaction })
 
     cache.invalidiateDeviceList = true
     cache.incrementTriggeredSyncLevel(2)

src/function/sync/apply-actions/dispatch-child-action/childchangepassword.ts

@@ -25,13 +25,13 @@ export const dispatchChildChangePassword = async ({ action, childUserId, cache }
   childUserId: string
   cache: Cache
 }) => {
-  const childEntry = await cache.database.user.findOne({
+  const childEntry = await cache.transaction.legacy.database.user.findOne({
     where: {
       familyId: cache.familyId,
       userId: childUserId,
       type: 'child'
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (!childEntry) {
@@ -44,7 +44,7 @@ export const dispatchChildChangePassword = async ({ action, childUserId, cache }
   childEntry.secondPasswordSalt = newPassword.secondSalt
   childEntry.secondPasswordHash = newPassword.secondHash
 
-  await childEntry.save({ transaction: cache.transaction })
+  await childEntry.save({ transaction: cache.transaction.legacy.transaction })
 
   {
     const clear = cache.getSecondPasswordHashOfChild.cache.clear

src/function/sync/apply-actions/dispatch-child-action/childsignin.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -39,13 +39,13 @@ export const dispatchChildSignIn = async ({ deviceId, childUserId, cache }: {
     cache
   })
 
-  const userEntryUnsafe = await cache.database.user.findOne({
+  const userEntryUnsafe = await cache.transaction.legacy.database.user.findOne({
     where: {
       familyId: cache.familyId,
       type: 'child',
       userId: childUserId
     },
-    transaction: cache.transaction,
+    transaction: cache.transaction.legacy.transaction,
     attributes: [
       'currentDevice'
     ]
@@ -58,7 +58,7 @@ export const dispatchChildSignIn = async ({ deviceId, childUserId, cache }: {
   if (userEntryUnsafe.currentDevice === deviceId) {
     // unassign to prevent way aroundprimary device rule
 
-    await cache.database.user.update({
+    await cache.transaction.legacy.database.user.update({
       currentDevice: ''
     }, {
       where: {
@@ -66,7 +66,7 @@ export const dispatchChildSignIn = async ({ deviceId, childUserId, cache }: {
         type: 'child',
         userId: childUserId
       },
-      transaction: cache.transaction
+      transaction: cache.transaction.legacy.transaction
     })
 
     cache.invalidiateUserList = true

src/function/sync/apply-actions/dispatch-helper/parent-action.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -45,14 +45,14 @@ export async function dispatchParentAction ({
     parser: parseParentAction,
     applier: async (parsedAction) => {
       if (isChildLimitAdding) {
-        const deviceEntryUnsafe = await cache.database.device.findOne({
+        const deviceEntryUnsafe = await cache.transaction.legacy.database.device.findOne({
           attributes: ['currentUserId'],
           where: {
             familyId: cache.familyId,
             deviceId,
             currentUserId: action.userId
           },
-          transaction: cache.transaction
+          transaction: cache.transaction.legacy.transaction
         })
 
         if (!deviceEntryUnsafe) {
@@ -67,14 +67,14 @@ export async function dispatchParentAction ({
           })
         }
 
-        const deviceUserEntryUnsafe = await cache.database.user.findOne({
+        const deviceUserEntryUnsafe = await cache.transaction.legacy.database.user.findOne({
           attributes: ['flags'],
           where: {
             familyId: cache.familyId,
             userId: deviceUserId,
             type: 'child'
           },
-          transaction: cache.transaction
+          transaction: cache.transaction.legacy.transaction
         })
 
         if (!deviceUserEntryUnsafe) {

src/function/sync/apply-actions/dispatch-parent-action/addcategoryapps.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -29,12 +29,12 @@ export async function dispatchAddCategoryApps ({ action, cache, fromChildSelfLim
   cache: Cache
   fromChildSelfLimitAddChildUserId: string | null
 }) {
-  const categoryEntryUnsafe = await cache.database.category.findOne({
+  const categoryEntryUnsafe = await cache.transaction.legacy.database.category.findOne({
     where: {
       familyId: cache.familyId,
       categoryId: action.categoryId
     },
-    transaction: cache.transaction,
+    transaction: cache.transaction.legacy.transaction,
     attributes: ['childId']
   })
 
@@ -50,13 +50,13 @@ export async function dispatchAddCategoryApps ({ action, cache, fromChildSelfLim
     }
   }
 
-  const categoriesOfSameChild = (await cache.database.category.findAll({
+  const categoriesOfSameChild = (await cache.transaction.legacy.database.category.findAll({
     where: {
       familyId: cache.familyId,
       childId
     },
     attributes: ['categoryId', 'parentCategoryId'],
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })).map((item) => ({
     categoryId: item.categoryId,
     parentCategoryId: item.parentCategoryId
@@ -64,7 +64,7 @@ export async function dispatchAddCategoryApps ({ action, cache, fromChildSelfLim
 
   const userCategoryIds = categoriesOfSameChild.map((item) => item.categoryId)
 
-  const oldCategories = (await cache.database.categoryApp.findAll({
+  const oldCategories = (await cache.transaction.legacy.database.categoryApp.findAll({
     attributes: [ 'categoryId' ],
     group: [ 'categoryId' ],
     where: {
@@ -76,7 +76,7 @@ export async function dispatchAddCategoryApps ({ action, cache, fromChildSelfLim
         [Sequelize.Op.in]: action.packageNames
       }
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })).map((item) => item.categoryId)
 
   if (fromChildSelfLimitAddChildUserId !== null) {
@@ -92,13 +92,13 @@ export async function dispatchAddCategoryApps ({ action, cache, fromChildSelfLim
 
     try {
       const parentCategoriesOfTargetCategory = getCategoryWithParentCategories(categoriesOfSameChild, action.categoryId)
-      const userEntryUnsafe = await cache.database.user.findOne({
+      const userEntryUnsafe = await cache.transaction.legacy.database.user.findOne({
         attributes: [ 'categoryForNotAssignedApps' ],
         where: {
           familyId: cache.familyId,
           userId: fromChildSelfLimitAddChildUserId
         },
-        transaction: cache.transaction
+        transaction: cache.transaction.legacy.transaction
       })
 
       if (!userEntryUnsafe) {
@@ -111,7 +111,7 @@ export async function dispatchAddCategoryApps ({ action, cache, fromChildSelfLim
         parentCategoriesOfTargetCategory.indexOf(validatedDefaultCategoryId) !== -1
 
       const assertCanAddApp = async (packageName: string, isApp: boolean) => {
-        const categoryAppEntryUnsafe = await cache.database.categoryApp.findOne({
+        const categoryAppEntryUnsafe = await cache.transaction.legacy.database.categoryApp.findOne({
           attributes: [ 'categoryId' ],
           where: {
             familyId: cache.familyId,
@@ -120,7 +120,7 @@ export async function dispatchAddCategoryApps ({ action, cache, fromChildSelfLim
             },
             packageName: packageName
           },
-          transaction: cache.transaction
+          transaction: cache.transaction.legacy.transaction
         })
 
         const categoryAppEntry = categoryAppEntryUnsafe ? { categoryId: categoryAppEntryUnsafe.categoryId } : null
@@ -162,7 +162,7 @@ export async function dispatchAddCategoryApps ({ action, cache, fromChildSelfLim
   }
 
   if (oldCategories.length > 0) {
-    await cache.database.categoryApp.destroy({
+    await cache.transaction.legacy.database.categoryApp.destroy({
       where: {
         familyId: cache.familyId,
         categoryId: {
@@ -172,18 +172,18 @@ export async function dispatchAddCategoryApps ({ action, cache, fromChildSelfLim
           [Sequelize.Op.in]: action.packageNames
         }
       },
-      transaction: cache.transaction
+      transaction: cache.transaction.legacy.transaction
     })
   }
 
-  await cache.database.categoryApp.bulkCreate(
+  await cache.transaction.legacy.database.categoryApp.bulkCreate(
     action.packageNames.map((packageName): CategoryAppAttributes => ({
       familyId: cache.familyId,
       categoryId: action.categoryId,
       packageName
     })),
     {
-      transaction: cache.transaction
+      transaction: cache.transaction.legacy.transaction
     }
   )
 

src/function/sync/apply-actions/dispatch-parent-action/addcategorynetworkid.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -25,12 +25,12 @@ export async function dispatchAddCategoryNetworkId ({ action, cache }: {
   action: AddCategoryNetworkIdAction
   cache: Cache
 }) {
-  const categoryEntryUnsafe = await cache.database.category.findOne({
+  const categoryEntryUnsafe = await cache.transaction.legacy.database.category.findOne({
     where: {
       familyId: cache.familyId,
       categoryId: action.categoryId
     },
-    transaction: cache.transaction,
+    transaction: cache.transaction.legacy.transaction,
     attributes: ['childId']
   })
 
@@ -38,12 +38,12 @@ export async function dispatchAddCategoryNetworkId ({ action, cache }: {
     throw new MissingCategoryException()
   }
 
-  const count = await cache.database.categoryNetworkId.count({
+  const count = await cache.transaction.legacy.database.categoryNetworkId.count({
     where: {
       familyId: cache.familyId,
       categoryId: action.categoryId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (count + 1 > maxNetworkIdsPerCategory) {
@@ -52,13 +52,13 @@ export async function dispatchAddCategoryNetworkId ({ action, cache }: {
     })
   }
 
-  const hasOldItem = (await cache.database.categoryNetworkId.count({
+  const hasOldItem = (await cache.transaction.legacy.database.categoryNetworkId.count({
     where: {
       familyId: cache.familyId,
       categoryId: action.categoryId,
       networkItemId: action.itemId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })) !== 0
 
   if (hasOldItem) {
@@ -67,12 +67,12 @@ export async function dispatchAddCategoryNetworkId ({ action, cache }: {
     })
   }
 
-  await cache.database.categoryNetworkId.create({
+  await cache.transaction.legacy.database.categoryNetworkId.create({
     familyId: cache.familyId,
     categoryId: action.categoryId,
     networkItemId: action.itemId,
     hashedNetworkId: action.hashedNetworkId
-  }, { transaction: cache.transaction })
+  }, { transaction: cache.transaction.legacy.transaction })
 
   cache.categoriesWithModifiedBaseData.add(action.categoryId)
   cache.incrementTriggeredSyncLevel(2)

src/function/sync/apply-actions/dispatch-parent-action/addu2fkey.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -25,16 +25,16 @@ export async function dispatchAddU2f ({ action, cache, parentUserId }: {
   cache: Cache
   parentUserId: string
 }) {
-  const counter = await cache.database.u2fKey.count({
+  const counter = await cache.transaction.legacy.database.u2fKey.count({
     where: {
       familyId: cache.familyId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (counter >= 16) throw new LimitReachedException({ type: 'u2f keys' })
 
-  await cache.database.u2fKey.create({
+  await cache.transaction.legacy.database.u2fKey.create({
     familyId: cache.familyId,
     keyId: getU2fKeyId({ keyHandle: action.keyHandle, publicKey: action.publicKey }),
     userId: parentUserId,
@@ -42,7 +42,7 @@ export async function dispatchAddU2f ({ action, cache, parentUserId }: {
     keyHandle: action.keyHandle,
     publicKey: action.publicKey,
     nextCounter: '0'
-  }, { transaction: cache.transaction })
+  }, { transaction: cache.transaction.legacy.transaction })
 
   cache.invalidateU2fList = true
   cache.incrementTriggeredSyncLevel(1)

src/function/sync/apply-actions/dispatch-parent-action/adduser.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -28,7 +28,7 @@ export async function dispatchAddUser ({ action, cache }: {
     await decryptParentPassword({ cache, password: action.password }) :
     null
 
-  await cache.database.user.create({
+  await cache.transaction.legacy.database.user.create({
     familyId: cache.familyId,
     userId: action.userId,
     type: action.userType,
@@ -45,7 +45,7 @@ export async function dispatchAddUser ({ action, cache }: {
     mailNotificationFlags: 0,
     blockedTimes: '',
     flags: '0'
-  }, { transaction: cache.transaction })
+  }, { transaction: cache.transaction.legacy.transaction })
 
   cache.invalidiateUserList = true
   cache.incrementTriggeredSyncLevel(1)

src/function/sync/apply-actions/dispatch-parent-action/changeparentpassword.ts

@@ -24,13 +24,13 @@ export async function dispatchChangeParentPassword ({ action, cache }: {
   action: ChangeParentPasswordAction
   cache: Cache
 }) {
-  const parentEntry = await cache.database.user.findOne({
+  const parentEntry = await cache.transaction.legacy.database.user.findOne({
     where: {
       familyId: cache.familyId,
       userId: action.parentUserId,
       type: 'parent'
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (!parentEntry) {
@@ -51,7 +51,7 @@ export async function dispatchChangeParentPassword ({ action, cache }: {
   parentEntry.secondPasswordSalt = action.newPasswordSecondSalt
   parentEntry.secondPasswordHash = newSecondPasswordHash
 
-  await parentEntry.save({ transaction: cache.transaction })
+  await parentEntry.save({ transaction: cache.transaction.legacy.transaction })
 
   {
     const clear = cache.getSecondPasswordHashOfParent.cache.clear

src/function/sync/apply-actions/dispatch-parent-action/createcategory.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -33,21 +33,21 @@ export async function dispatchCreateCategory ({ action, cache, fromChildSelfLimi
   }
 
   // check that the child exists
-  const childEntry = await cache.database.user.findOne({
+  const childEntry = await cache.transaction.legacy.database.user.findOne({
     where: {
       familyId: cache.familyId,
       userId: action.childId,
       type: 'child'
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (!childEntry) {
     throw new MissingUserException()
   }
 
-  const oldMaxSort: number = await cache.database.category.max('sort', {
+  const oldMaxSort: number = await cache.transaction.legacy.database.category.max('sort', {
-    transaction: cache.transaction,
+    transaction: cache.transaction.legacy.transaction,
     where: {
       familyId: cache.familyId,
       childId: action.childId
@@ -58,7 +58,7 @@ export async function dispatchCreateCategory ({ action, cache, fromChildSelfLimi
   const sort = Number.isSafeInteger(oldMaxSort + 1) ? (oldMaxSort + 1) : 0
 
   // no version number needs to be updated
-  await cache.database.category.create({
+  await cache.transaction.legacy.database.category.create({
     familyId: cache.familyId,
     categoryId: action.categoryId,
     childId: action.childId,
@@ -82,7 +82,7 @@ export async function dispatchCreateCategory ({ action, cache, fromChildSelfLimi
     minBatteryMobile: 0,
     flags: '0',
     blockNotificationDelay: '0'
-  }, { transaction: cache.transaction })
+  }, { transaction: cache.transaction.legacy.transaction })
 
   // update the cache
   cache.doesCategoryExist.cache.set(action.categoryId, true)

src/function/sync/apply-actions/dispatch-parent-action/createtimelimitrule.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2024 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -25,12 +25,12 @@ export async function dispatchCreateTimeLimitRule ({ action, cache, fromChildSel
   cache: Cache
   fromChildSelfLimitAddChildUserId: string | null
 }) {
-  const categoryEntryUnsafe = await cache.database.category.findOne({
+  const categoryEntryUnsafe = await cache.transaction.legacy.database.category.findOne({
     where: {
       familyId: cache.familyId,
       categoryId: action.rule.categoryId
     },
-    transaction: cache.transaction,
+    transaction: cache.transaction.legacy.transaction,
     attributes: ['childId']
   })
 
@@ -44,7 +44,7 @@ export async function dispatchCreateTimeLimitRule ({ action, cache, fromChildSel
     }
   }
 
-  await cache.database.timelimitRule.create({
+  await cache.transaction.legacy.database.timelimitRule.create({
     familyId: cache.familyId,
     ruleId: action.rule.ruleId,
     categoryId: action.rule.categoryId,
@@ -57,7 +57,7 @@ export async function dispatchCreateTimeLimitRule ({ action, cache, fromChildSel
     sessionPauseMilliseconds: action.rule.sessionPauseMilliseconds,
     perDay: action.rule.perDay ? 1 : 0,
     expiresAt: action.rule.expiresAt ? action.rule.expiresAt.toString() : null
-  }, { transaction: cache.transaction })
+  }, { transaction: cache.transaction.legacy.transaction })
 
   cache.categoriesWithModifiedTimeLimitRules.add(action.rule.categoryId)
   cache.incrementTriggeredSyncLevel(2)

src/function/sync/apply-actions/dispatch-parent-action/deletecategory.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -23,59 +23,59 @@ export async function dispatchDeleteCategory ({ action, cache }: {
   action: DeleteCategoryAction
   cache: Cache
 }) {
-  const { familyId, transaction } = cache
+  const { familyId } = cache
   const { categoryId } = action
 
-  const categoryEntry = await cache.database.category.findOne({
+  const categoryEntry = await cache.transaction.legacy.database.category.findOne({
     where: {
       familyId,
       categoryId
     },
-    transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (!categoryEntry) { throw new MissingCategoryException() }
 
-  await cache.database.timelimitRule.destroy({
+  await cache.transaction.legacy.database.timelimitRule.destroy({
     where: {
       familyId,
       categoryId
     },
-    transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
-  await cache.database.usedTime.destroy({
+  await cache.transaction.legacy.database.usedTime.destroy({
     where: {
       familyId,
       categoryId
     },
-    transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
-  await cache.database.categoryApp.destroy({
+  await cache.transaction.legacy.database.categoryApp.destroy({
     where: {
       familyId,
       categoryId
     },
-    transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
-  const [affectedUserRows] = await cache.database.user.update({
+  const [affectedUserRows] = await cache.transaction.legacy.database.user.update({
     categoryForNotAssignedApps: ''
   }, {
     where: {
       familyId,
       categoryForNotAssignedApps: categoryId
     },
-    transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
-  await cache.database.category.destroy({
+  await cache.transaction.legacy.database.category.destroy({
     where: {
       familyId,
       categoryId
     },
-    transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   // update the cache

src/function/sync/apply-actions/dispatch-parent-action/deletechildtaskaction.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -23,12 +23,12 @@ export async function dispatchDeleteChildTaskAction ({ action, cache }: {
   action: DeleteChildTaskAction
   cache: Cache
 }) {
-  const taskInfoUnsafe = await cache.database.childTask.findOne({
+  const taskInfoUnsafe = await cache.transaction.legacy.database.childTask.findOne({
     where: {
       familyId: cache.familyId,
       taskId: action.taskId
     },
-    transaction: cache.transaction,
+    transaction: cache.transaction.legacy.transaction,
     attributes: ['categoryId']
   })
 
@@ -36,12 +36,12 @@ export async function dispatchDeleteChildTaskAction ({ action, cache }: {
 
   const taskInfo = { categoryId: taskInfoUnsafe.categoryId }
 
-  await cache.database.childTask.destroy({
+  await cache.transaction.legacy.database.childTask.destroy({
     where: {
       familyId: cache.familyId,
       taskId: action.taskId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   cache.categoriesWithModifiedTasks.add(taskInfo.categoryId)

src/function/sync/apply-actions/dispatch-parent-action/deletetimelimitrule.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -23,19 +23,19 @@ export async function dispatchDeleteTimeLimitRule ({ action, cache }: {
   action: DeleteTimeLimitRuleAction
   cache: Cache
 }) {
-  const ruleEntry = await cache.database.timelimitRule.findOne({
+  const ruleEntry = await cache.transaction.legacy.database.timelimitRule.findOne({
     where: {
       familyId: cache.familyId,
       ruleId: action.ruleId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (!ruleEntry) {
     throw new MissingRuleException()
   }
 
-  await ruleEntry.destroy({ transaction: cache.transaction })
+  await ruleEntry.destroy({ transaction: cache.transaction.legacy.transaction })
 
   cache.categoriesWithModifiedTimeLimitRules.add(ruleEntry.categoryId)
   cache.incrementTriggeredSyncLevel(2)

src/function/sync/apply-actions/dispatch-parent-action/ignoremanipulation.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -23,12 +23,12 @@ export async function dispatchIgnoreManipulation ({ action, cache }: {
   action: IgnoreManipulationAction
   cache: Cache
 }) {
-  const deviceEntry = await cache.database.device.findOne({
+  const deviceEntry = await cache.transaction.legacy.database.device.findOne({
     where: {
       familyId: cache.familyId,
       deviceId: action.deviceId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (deviceEntry === null) {
@@ -85,7 +85,7 @@ export async function dispatchIgnoreManipulation ({ action, cache }: {
     deviceEntry.manipulationFlags = deviceEntry.manipulationFlags & (~action.ignoreManipulationFlags)
   }
 
-  await deviceEntry.save({ transaction: cache.transaction })
+  await deviceEntry.save({ transaction: cache.transaction.legacy.transaction })
   cache.invalidiateDeviceList = true
   cache.incrementTriggeredSyncLevel(1)
   cache.incrementTargetedTriggeredSyncLevel(action.deviceId, 2)

src/function/sync/apply-actions/dispatch-parent-action/incrementcategoryextratime.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -38,18 +38,18 @@ export async function dispatchIncrementCategoryExtraTime ({ action, cache }: {
 
     category.extraTimeDay = action.day
 
-    await category.save({ transaction: cache.transaction })
+    await category.save({ transaction: cache.transaction.legacy.transaction })
 
     cache.categoriesWithModifiedBaseData.add(category.categoryId)
     cache.incrementTriggeredSyncLevel(2)
   }
 
-  const categoryEntry = await cache.database.category.findOne({
+  const categoryEntry = await cache.transaction.legacy.database.category.findOne({
     where: {
       familyId: cache.familyId,
       categoryId: action.categoryId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (!categoryEntry) {
@@ -59,12 +59,12 @@ export async function dispatchIncrementCategoryExtraTime ({ action, cache }: {
   await handleCategory(categoryEntry)
 
   if (categoryEntry.parentCategoryId !== '') {
-    const parentCategoryEntry = await cache.database.category.findOne({
+    const parentCategoryEntry = await cache.transaction.legacy.database.category.findOne({
       where: {
         familyId: cache.familyId,
         categoryId: categoryEntry.parentCategoryId
       },
-      transaction: cache.transaction
+      transaction: cache.transaction.legacy.transaction
     })
 
     if (parentCategoryEntry) {

src/function/sync/apply-actions/dispatch-parent-action/removecategoryapps.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -24,7 +24,7 @@ export async function dispatchRemoveCategoryApps ({ action, cache }: {
   action: RemoveCategoryAppsAction
   cache: Cache
 }) {
-  const affectedRows = await cache.database.categoryApp.destroy({
+  const affectedRows = await cache.transaction.legacy.database.categoryApp.destroy({
     where: {
       familyId: cache.familyId,
       categoryId: action.categoryId,
@@ -32,7 +32,7 @@ export async function dispatchRemoveCategoryApps ({ action, cache }: {
         [Sequelize.Op.in]: action.packageNames
       }
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (affectedRows !== action.packageNames.length) {

src/function/sync/apply-actions/dispatch-parent-action/removeu2fkey.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -31,7 +31,7 @@ export async function dispatchRemoveU2f ({ action, cache, parentUserId, authenti
     throw new ApplyActionUnacceptableAuthMethodException()
   }
 
-  await cache.database.u2fKey.destroy({
+  await cache.transaction.legacy.database.u2fKey.destroy({
     where: {
       familyId: cache.familyId,
       keyId: getU2fKeyId({ keyHandle: action.keyHandle, publicKey: action.publicKey }),
@@ -39,7 +39,7 @@ export async function dispatchRemoveU2f ({ action, cache, parentUserId, authenti
       keyHandle: action.keyHandle,
       publicKey: action.publicKey
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   cache.invalidateU2fList = true

src/function/sync/apply-actions/dispatch-parent-action/removeuser.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -30,12 +30,12 @@ export async function dispatchRemoveUser ({ action, cache, parentUserId }: {
   cache: Cache
   parentUserId: string
 }) {
-  const user = await cache.database.user.findOne({
+  const user = await cache.transaction.legacy.database.user.findOne({
     where: {
       familyId: cache.familyId,
       userId: action.userId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (!user) {
@@ -60,8 +60,8 @@ export async function dispatchRemoveUser ({ action, cache, parentUserId }: {
     }
 
     if (user.mail !== '') {
-      const usersWithLinkedMail = await cache.database.user.count({
+      const usersWithLinkedMail = await cache.transaction.legacy.database.user.count({
-        transaction: cache.transaction,
+        transaction: cache.transaction.legacy.transaction,
         where: {
           familyId: cache.familyId,
           type: 'parent',
@@ -76,16 +76,16 @@ export async function dispatchRemoveUser ({ action, cache, parentUserId }: {
       }
     }
 
-    const usersWithLimitLoginCategories = (await cache.database.userLimitLoginCategory.findAll({
+    const usersWithLimitLoginCategories = (await cache.transaction.legacy.database.userLimitLoginCategory.findAll({
-      transaction: cache.transaction,
+      transaction: cache.transaction.legacy.transaction,
       where: {
         familyId: cache.familyId
       },
       attributes: ['userId']
     })).map((item) => item.userId)
 
-    const allParentUserIds = (await cache.database.user.findAll({
+    const allParentUserIds = (await cache.transaction.legacy.database.user.findAll({
-      transaction: cache.transaction,
+      transaction: cache.transaction.legacy.transaction,
       where: {
         familyId: cache.familyId,
         type: 'parent'
@@ -101,56 +101,56 @@ export async function dispatchRemoveUser ({ action, cache, parentUserId }: {
   }
 
   if (user.type === 'child') {
-    const categories = await cache.database.category.findAll({
+    const categories = await cache.transaction.legacy.database.category.findAll({
       where: {
         familyId: cache.familyId,
         childId: action.userId
       },
-      transaction: cache.transaction
+      transaction: cache.transaction.legacy.transaction
     })
 
-    await cache.database.categoryApp.destroy({
+    await cache.transaction.legacy.database.categoryApp.destroy({
       where: {
         familyId: cache.familyId,
         categoryId: {
           [Sequelize.Op.in]: categories.map((category) => category.categoryId)
         }
       },
-      transaction: cache.transaction
+      transaction: cache.transaction.legacy.transaction
     })
 
-    await cache.database.timelimitRule.destroy({
+    await cache.transaction.legacy.database.timelimitRule.destroy({
       where: {
         familyId: cache.familyId,
         categoryId: {
           [Sequelize.Op.in]: categories.map((category) => category.categoryId)
         }
       },
-      transaction: cache.transaction
+      transaction: cache.transaction.legacy.transaction
     })
 
-    await cache.database.usedTime.destroy({
+    await cache.transaction.legacy.database.usedTime.destroy({
       where: {
         familyId: cache.familyId,
         categoryId: {
           [Sequelize.Op.in]: categories.map((category) => category.categoryId)
         }
       },
-      transaction: cache.transaction
+      transaction: cache.transaction.legacy.transaction
     })
 
-    await cache.database.category.destroy({
+    await cache.transaction.legacy.database.category.destroy({
       where: {
         familyId: cache.familyId,
         categoryId: {
           [Sequelize.Op.in]: categories.map((category) => category.categoryId)
         }
       },
-      transaction: cache.transaction
+      transaction: cache.transaction.legacy.transaction
     })
   }
 
-  const [updatedDevices1] = await cache.database.device.update({
+  const [updatedDevices1] = await cache.transaction.legacy.database.device.update({
     currentUserId: '',
     isUserKeptSignedIn: false
   }, {
@@ -158,24 +158,24 @@ export async function dispatchRemoveUser ({ action, cache, parentUserId }: {
       familyId: cache.familyId,
       currentUserId: action.userId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
-  const [updatedDevices2] = await cache.database.device.update({
+  const [updatedDevices2] = await cache.transaction.legacy.database.device.update({
     defaultUserId: ''
   }, {
     where: {
       familyId: cache.familyId,
       defaultUserId: action.userId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (updatedDevices1 > 0 || updatedDevices2 > 0) {
     cache.invalidiateDeviceList = true
   }
 
-  await user.destroy({ transaction: cache.transaction })
+  await user.destroy({ transaction: cache.transaction.legacy.transaction })
 
   cache.invalidiateUserList = true
   cache.incrementTriggeredSyncLevel(2)

src/function/sync/apply-actions/dispatch-parent-action/renamechild.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -23,20 +23,20 @@ export async function dispatchRenameChild ({ action, cache }: {
   action: RenameChildAction
   cache: Cache
 }) {
-  const oldItem = await cache.database.user.findOne({
+  const oldItem = await cache.transaction.legacy.database.user.findOne({
     where: {
       familyId: cache.familyId,
       userId: action.childId,
       type: 'child'
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (!oldItem) {
     throw new MissingUserException()
   }
 
-  await cache.database.user.update({
+  await cache.transaction.legacy.database.user.update({
     name: action.newName
   }, {
     where: {
@@ -44,7 +44,7 @@ export async function dispatchRenameChild ({ action, cache }: {
       userId: action.childId,
       type: 'child'
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   cache.invalidiateUserList = true

src/function/sync/apply-actions/dispatch-parent-action/resetcategorynetworkids.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -23,12 +23,12 @@ export async function dispatchResetCategoryNetworkIds ({ action, cache }: {
   action: ResetCategoryNetworkIdsAction
   cache: Cache
 }) {
-  const categoryEntryUnsafe = await cache.database.category.findOne({
+  const categoryEntryUnsafe = await cache.transaction.legacy.database.category.findOne({
     where: {
       familyId: cache.familyId,
       categoryId: action.categoryId
     },
-    transaction: cache.transaction,
+    transaction: cache.transaction.legacy.transaction,
     attributes: ['childId']
   })
 
@@ -36,12 +36,12 @@ export async function dispatchResetCategoryNetworkIds ({ action, cache }: {
     throw new MissingCategoryException()
   }
 
-  await cache.database.categoryNetworkId.destroy({
+  await cache.transaction.legacy.database.categoryNetworkId.destroy({
     where: {
       familyId: cache.familyId,
       categoryId: action.categoryId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   cache.categoriesWithModifiedBaseData.add(action.categoryId)

src/function/sync/apply-actions/dispatch-parent-action/reviewchildtaskaction.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -29,12 +29,12 @@ export async function dispatchReviewChildTaskAction ({ action, cache }: {
     throw new PremiumVersionMissingException()
   }
 
-  const taskInfo = await cache.database.childTask.findOne({
+  const taskInfo = await cache.transaction.legacy.database.childTask.findOne({
     where: {
       familyId: cache.familyId,
       taskId: action.taskId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (taskInfo === null) throw new MissingTaskException()
@@ -42,13 +42,13 @@ export async function dispatchReviewChildTaskAction ({ action, cache }: {
   if (taskInfo.pendingRequest === 0) throw new IllegalStateException({ staticMessage: 'no task review pending' })
 
   if (action.ok) {
-    const categoryInfoUnsafe = await cache.database.category.findOne({
+    const categoryInfoUnsafe = await cache.transaction.legacy.database.category.findOne({
       where: {
         familyId: cache.familyId,
         categoryId: taskInfo.categoryId
       },
       attributes: ['extraTimeInMillis', 'extraTimeDay'],
-      transaction: cache.transaction
+      transaction: cache.transaction.legacy.transaction
     })
 
     if (categoryInfoUnsafe === null) {
@@ -64,7 +64,7 @@ export async function dispatchReviewChildTaskAction ({ action, cache }: {
       action.day !== undefined && categoryInfo.extraTimeDay !== action.day
 
     if (resetDayBoundExtraTime) {
-      await cache.database.category.update({
+      await cache.transaction.legacy.database.category.update({
         extraTimeInMillis: taskInfo.extraTimeDuration,
         extraTimeDay: -1
       }, {
@@ -72,23 +72,23 @@ export async function dispatchReviewChildTaskAction ({ action, cache }: {
           familyId: cache.familyId,
           categoryId: taskInfo.categoryId
         },
-        transaction: cache.transaction
+        transaction: cache.transaction.legacy.transaction
       })
     } else {
-      await cache.database.category.update({
+      await cache.transaction.legacy.database.category.update({
         extraTimeInMillis: categoryInfo.extraTimeInMillis + taskInfo.extraTimeDuration
       }, {
         where: {
           familyId: cache.familyId,
           categoryId: taskInfo.categoryId
         },
-        transaction: cache.transaction
+        transaction: cache.transaction.legacy.transaction
       })
     }
 
     cache.categoriesWithModifiedBaseData.add(taskInfo.categoryId)
 
-    await cache.database.childTask.update({
+    await cache.transaction.legacy.database.childTask.update({
       pendingRequest: 0,
       lastGrantTimestamp: action.time.toString(10)
     }, {
@@ -96,19 +96,19 @@ export async function dispatchReviewChildTaskAction ({ action, cache }: {
         familyId: cache.familyId,
         taskId: action.taskId
       },
-      transaction: cache.transaction
+      transaction: cache.transaction.legacy.transaction
     })
 
     cache.incrementTriggeredSyncLevel(2)
   } else {
-    await cache.database.childTask.update({
+    await cache.transaction.legacy.database.childTask.update({
       pendingRequest: 0
     }, {
       where: {
         familyId: cache.familyId,
         taskId: action.taskId
       },
-      transaction: cache.transaction
+      transaction: cache.transaction.legacy.transaction
     })
   }
 

src/function/sync/apply-actions/dispatch-parent-action/setcategoryextratime.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -28,19 +28,19 @@ export async function dispatchSetCategoryExtraTime ({ action, cache }: {
     throw new PremiumVersionMissingException()
   }
 
-  const oldItem = await cache.database.category.findOne({
+  const oldItem = await cache.transaction.legacy.database.category.findOne({
     where: {
       familyId: cache.familyId,
       categoryId: action.categoryId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (!oldItem) {
     throw new MissingCategoryException()
   }
 
-  await cache.database.category.update({
+  await cache.transaction.legacy.database.category.update({
     extraTimeInMillis: action.newExtraTime,
     extraTimeDay: action.day
   }, {
@@ -48,7 +48,7 @@ export async function dispatchSetCategoryExtraTime ({ action, cache }: {
       familyId: cache.familyId,
       categoryId: action.categoryId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   cache.categoriesWithModifiedBaseData.add(action.categoryId)

src/function/sync/apply-actions/dispatch-parent-action/setcategoryforunassignedapps.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -24,13 +24,13 @@ export async function dispatchSetCategoryForUnassignedApps ({ action, cache }: {
   action: SetCategoryForUnassignedAppsAction
   cache: Cache
 }) {
-  const oldUserEntry = await cache.database.user.findOne({
+  const oldUserEntry = await cache.transaction.legacy.database.user.findOne({
     where: {
       familyId: cache.familyId,
       userId: action.childId,
       type: 'child'
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (!oldUserEntry) {
@@ -40,13 +40,13 @@ export async function dispatchSetCategoryForUnassignedApps ({ action, cache }: {
   if (action.categoryId === '') {
     // nothing to check
   } else {
-    const categoryEntryUnsafe = await cache.database.category.findOne({
+    const categoryEntryUnsafe = await cache.transaction.legacy.database.category.findOne({
       attributes: ['childId'],
       where: {
         familyId: cache.familyId,
         categoryId: action.categoryId
       },
-      transaction: cache.transaction
+      transaction: cache.transaction.legacy.transaction
     })
 
     if (!categoryEntryUnsafe) {
@@ -66,7 +66,7 @@ export async function dispatchSetCategoryForUnassignedApps ({ action, cache }: {
     }
   }
 
-  await cache.database.user.update({
+  await cache.transaction.legacy.database.user.update({
     categoryForNotAssignedApps: action.categoryId
   }, {
     where: {
@@ -74,7 +74,7 @@ export async function dispatchSetCategoryForUnassignedApps ({ action, cache }: {
       userId: action.childId,
       type: 'child'
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   cache.invalidiateUserList = true

src/function/sync/apply-actions/dispatch-parent-action/setchildpassword.ts

@@ -24,13 +24,13 @@ export async function dispatchSetChildPassword ({ action, cache }: {
   action: SetChildPasswordAction
   cache: Cache
 }) {
-  const childEntry = await cache.database.user.findOne({
+  const childEntry = await cache.transaction.legacy.database.user.findOne({
     where: {
       familyId: cache.familyId,
       userId: action.childUserId,
       type: 'child'
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (!childEntry) {
@@ -43,7 +43,7 @@ export async function dispatchSetChildPassword ({ action, cache }: {
   childEntry.secondPasswordSalt = newPassword.secondSalt
   childEntry.secondPasswordHash = newPassword.secondHash
 
-  await childEntry.save({ transaction: cache.transaction })
+  await childEntry.save({ transaction: cache.transaction.legacy.transaction })
 
   {
     const clear = cache.getSecondPasswordHashOfChild.cache.clear

src/function/sync/apply-actions/dispatch-parent-action/setconsiderrebootmanipulation.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -23,8 +23,8 @@ export async function dispatchSetConsiderRebootManipulation ({ action, cache }:
   action: SetConsiderRebootManipulationAction
   cache: Cache
 }) {
-  const oldDevice = await cache.database.device.findOne({
+  const oldDevice = await cache.transaction.legacy.database.device.findOne({
-    transaction: cache.transaction,
+    transaction: cache.transaction.legacy.transaction,
     where: {
       familyId: cache.familyId,
       deviceId: action.deviceId
@@ -35,10 +35,10 @@ export async function dispatchSetConsiderRebootManipulation ({ action, cache }:
     throw new MissingDeviceException()
   }
 
-  await cache.database.device.update({
+  await cache.transaction.legacy.database.device.update({
     considerRebootManipulation: action.enable
   }, {
-    transaction: cache.transaction,
+    transaction: cache.transaction.legacy.transaction,
     where: {
       familyId: cache.familyId,
       deviceId: action.deviceId

src/function/sync/apply-actions/dispatch-parent-action/setdevicedefaultuser.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -31,8 +31,8 @@ export async function dispatchSetDeviceDefaultUser ({ action, cache }: {
     }
   }
 
-  const oldDeviceItem = await cache.database.device.findOne({
+  const oldDeviceItem = await cache.transaction.legacy.database.device.findOne({
-    transaction: cache.transaction,
+    transaction: cache.transaction.legacy.transaction,
     where: {
       familyId: cache.familyId,
       deviceId: action.deviceId
@@ -43,10 +43,10 @@ export async function dispatchSetDeviceDefaultUser ({ action, cache }: {
     throw new MissingDeviceException()
   }
 
-  await cache.database.device.update({
+  await cache.transaction.legacy.database.device.update({
     defaultUserId: action.defaultUserId
   }, {
-    transaction: cache.transaction,
+    transaction: cache.transaction.legacy.transaction,
     where: {
       familyId: cache.familyId,
       deviceId: action.deviceId

src/function/sync/apply-actions/dispatch-parent-action/setdevicedefaultusertimeout.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2020 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -23,8 +23,8 @@ export async function dispatchSetDeviceDefaultUserTimeout ({ action, cache }: {
   action: SetDeviceDefaultUserTimeoutAction
   cache: Cache
 }) {
-  const oldDeviceItem = await cache.database.device.findOne({
+  const oldDeviceItem = await cache.transaction.legacy.database.device.findOne({
-    transaction: cache.transaction,
+    transaction: cache.transaction.legacy.transaction,
     where: {
       familyId: cache.familyId,
       deviceId: action.deviceId
@@ -35,10 +35,10 @@ export async function dispatchSetDeviceDefaultUserTimeout ({ action, cache }: {
     throw new MissingDeviceException()
   }
 
-  await cache.database.device.update({
+  await cache.transaction.legacy.database.device.update({
     defaultUserTimeout: action.timeout
   }, {
-    transaction: cache.transaction,
+    transaction: cache.transaction.legacy.transaction,
     where: {
       familyId: cache.familyId,
       deviceId: action.deviceId

src/function/sync/apply-actions/dispatch-parent-action/setdeviceuser.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -31,19 +31,19 @@ export async function dispatchSetDeviceUser ({ action, cache }: {
     }
   }
 
-  const oldDeviceItem = await cache.database.device.findOne({
+  const oldDeviceItem = await cache.transaction.legacy.database.device.findOne({
     where: {
       familyId: cache.familyId,
       deviceId: action.deviceId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (!oldDeviceItem) {
     throw new MissingDeviceException()
   }
 
-  await cache.database.device.update({
+  await cache.transaction.legacy.database.device.update({
     currentUserId: action.userId,
     isUserKeptSignedIn: false
   }, {
@@ -51,7 +51,7 @@ export async function dispatchSetDeviceUser ({ action, cache }: {
       familyId: cache.familyId,
       deviceId: action.deviceId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   cache.invalidiateDeviceList = true

src/function/sync/apply-actions/dispatch-parent-action/setkeepsignedin.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -32,12 +32,12 @@ export async function dispatchSetKeepSignedIn ({ action, cache, parentUserId }:
     throw new SourceUserNotFoundException()
   }
 
-  const deviceEntry = await cache.database.device.findOne({
+  const deviceEntry = await cache.transaction.legacy.database.device.findOne({
     where: {
       familyId: cache.familyId,
       deviceId: action.deviceId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (!deviceEntry) {
@@ -50,7 +50,7 @@ export async function dispatchSetKeepSignedIn ({ action, cache, parentUserId }:
     }
   }
 
-  const [affectedRows] = await cache.database.device.update({
+  const [affectedRows] = await cache.transaction.legacy.database.device.update({
     isUserKeptSignedIn: action.keepSignedIn
   }, {
     where: {
@@ -58,7 +58,7 @@ export async function dispatchSetKeepSignedIn ({ action, cache, parentUserId }:
       deviceId: action.deviceId,
       currentUserId: deviceEntry.currentUserId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (affectedRows !== 0) {

src/function/sync/apply-actions/dispatch-parent-action/setparentcategory.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -27,12 +27,12 @@ export async function dispatchSetParentCategory ({ action, cache, fromChildSelfL
   cache: Cache
   fromChildSelfLimitAddChildUserId: string | null
 }) {
-  const categoryEntry = await cache.database.category.findOne({
+  const categoryEntry = await cache.transaction.legacy.database.category.findOne({
     where: {
       familyId: cache.familyId,
       categoryId: action.categoryId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (!categoryEntry) {
@@ -46,13 +46,13 @@ export async function dispatchSetParentCategory ({ action, cache, fromChildSelfL
   }
 
   if (action.parentCategory !== '') {
-    const categoriesByUserId = (await cache.database.category.findAll({
+    const categoriesByUserId = (await cache.transaction.legacy.database.category.findAll({
       where: {
         familyId: cache.familyId,
         childId: categoryEntry.childId
       },
       attributes: ['categoryId', 'parentCategoryId'],
-      transaction: cache.transaction
+      transaction: cache.transaction.legacy.transaction
     })).map((item) => ({
       categoryId: item.categoryId,
       parentCategoryId: item.parentCategoryId
@@ -107,14 +107,14 @@ export async function dispatchSetParentCategory ({ action, cache, fromChildSelfL
     }
   }
 
-  await cache.database.category.update({
+  await cache.transaction.legacy.database.category.update({
     parentCategoryId: action.parentCategory
   }, {
     where: {
       familyId: cache.familyId,
       categoryId: action.categoryId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   cache.categoriesWithModifiedBaseData.add(action.categoryId)

src/function/sync/apply-actions/dispatch-parent-action/setrelaxprimarydevice.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -23,8 +23,8 @@ export async function dispatchSetRelaxPrimaryDevice ({ action, cache }: {
   action: SetRelaxPrimaryDeviceAction
   cache: Cache
 }) {
-  const oldUser = cache.database.user.findOne({
+  const oldUser = cache.transaction.legacy.database.user.findOne({
-    transaction: cache.transaction,
+    transaction: cache.transaction.legacy.transaction,
     where: {
       familyId: cache.familyId,
       userId: action.userId,
@@ -36,10 +36,10 @@ export async function dispatchSetRelaxPrimaryDevice ({ action, cache }: {
     throw new MissingUserException()
   }
 
-  await cache.database.user.update({
+  await cache.transaction.legacy.database.user.update({
     relaxPrimaryDeviceRule: action.relax
   }, {
-    transaction: cache.transaction,
+    transaction: cache.transaction.legacy.transaction,
     where: {
       familyId: cache.familyId,
       userId: action.userId,

src/function/sync/apply-actions/dispatch-parent-action/setsenddeviceconnected.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -30,10 +30,10 @@ export async function dispatchSetSendDeviceConnected ({ action, cache, sourceDev
     })
   }
 
-  await cache.database.device.update({
+  await cache.transaction.legacy.database.device.update({
     showDeviceConnected: action.enable
   }, {
-    transaction: cache.transaction,
+    transaction: cache.transaction.legacy.transaction,
     where: {
       familyId: cache.familyId,
       deviceId: action.deviceId

src/function/sync/apply-actions/dispatch-parent-action/setuserdisablelmitsuntil.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -30,20 +30,20 @@ export async function dispatchUserSetDisableLimitsUntil ({ action, cache }: {
     }
   }
 
-  const oldUser = await cache.database.user.findOne({
+  const oldUser = await cache.transaction.legacy.database.user.findOne({
     where: {
       familyId: cache.familyId,
       userId: action.childId,
       type: 'child'
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (!oldUser) {
     throw new MissingUserException()
   }
 
-  await cache.database.user.update({
+  await cache.transaction.legacy.database.user.update({
     disableTimelimitsUntil: action.timestamp.toString(10)
   }, {
     where: {
@@ -51,7 +51,7 @@ export async function dispatchUserSetDisableLimitsUntil ({ action, cache }: {
       userId: action.childId,
       type: 'child'
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   cache.invalidiateUserList = true

src/function/sync/apply-actions/dispatch-parent-action/setusertimezone.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -23,22 +23,22 @@ export async function dispatchSetUserTimezone ({ action, cache }: {
   action: SetUserTimezoneAction
   cache: Cache
 }) {
-  const oldUser = await cache.database.user.findOne({
+  const oldUser = await cache.transaction.legacy.database.user.findOne({
     where: {
       familyId: cache.familyId,
       userId: action.userId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (!oldUser) {
     throw new MissingUserException()
   }
 
-  await cache.database.user.update({
+  await cache.transaction.legacy.database.user.update({
     timeZone: action.timezone
   }, {
-    transaction: cache.transaction,
+    transaction: cache.transaction.legacy.transaction,
     where: {
       familyId: cache.familyId,
       userId: action.userId

src/function/sync/apply-actions/dispatch-parent-action/updatecategorybatterylimit.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -23,12 +23,12 @@ export async function dispatchUpdateCategoryBatteryLimit ({ action, cache }: {
   action: UpdateCategoryBatteryLimitAction
   cache: Cache
 }) {
-  const categoryEntry = await cache.database.category.findOne({
+  const categoryEntry = await cache.transaction.legacy.database.category.findOne({
     where: {
       familyId: cache.familyId,
       categoryId: action.categoryId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (!categoryEntry) {
@@ -43,7 +43,7 @@ export async function dispatchUpdateCategoryBatteryLimit ({ action, cache }: {
     categoryEntry.minBatteryMobile = action.mobileLimit
   }
 
-  await categoryEntry.save({ transaction: cache.transaction })
+  await categoryEntry.save({ transaction: cache.transaction.legacy.transaction })
 
   cache.categoriesWithModifiedBaseData.add(action.categoryId)
   cache.incrementTriggeredSyncLevel(2)

src/function/sync/apply-actions/dispatch-parent-action/updatecategoryblockallnotifications.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -25,12 +25,12 @@ export async function dispatchUpdateCategoryBlockAllNotifications ({ action, cac
   cache: Cache
   fromChildSelfLimitAddChildUserId: string | null
 }) {
-  const categoryEntryUnsafe = await cache.database.category.findOne({
+  const categoryEntryUnsafe = await cache.transaction.legacy.database.category.findOne({
     where: {
       familyId: cache.familyId,
       categoryId: action.categoryId
     },
-    transaction: cache.transaction,
+    transaction: cache.transaction.legacy.transaction,
     attributes: ['childId', 'blockAllNotifications']
   })
 
@@ -57,7 +57,7 @@ export async function dispatchUpdateCategoryBlockAllNotifications ({ action, cac
     }
   }
 
-  const [affectedRows] = await cache.database.category.update(action.blockDelay === undefined ? {
+  const [affectedRows] = await cache.transaction.legacy.database.category.update(action.blockDelay === undefined ? {
     blockAllNotifications: action.blocked
   } : {
     blockAllNotifications: action.blocked,
@@ -67,7 +67,7 @@ export async function dispatchUpdateCategoryBlockAllNotifications ({ action, cac
       familyId: cache.familyId,
       categoryId: action.categoryId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (affectedRows !== 0) {

src/function/sync/apply-actions/dispatch-parent-action/updatecategoryblockedtimes.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -26,12 +26,12 @@ export async function dispatchUpdateCategoryBlockedTimes ({ action, cache, fromC
   cache: Cache
   fromChildSelfLimitAddChildUserId: string | null
 }) {
-  const categoryEntryUnsafe = await cache.database.category.findOne({
+  const categoryEntryUnsafe = await cache.transaction.legacy.database.category.findOne({
     where: {
       familyId: cache.familyId,
       categoryId: action.categoryId
     },
-    transaction: cache.transaction,
+    transaction: cache.transaction.legacy.transaction,
     attributes: ['childId', 'blockedMinutesInWeek']
   })
 
@@ -59,14 +59,14 @@ export async function dispatchUpdateCategoryBlockedTimes ({ action, cache, fromC
     })
   }
 
-  await cache.database.category.update({
+  await cache.transaction.legacy.database.category.update({
     blockedMinutesInWeek: action.blockedTimes
   }, {
     where: {
       familyId: cache.familyId,
       categoryId: action.categoryId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   cache.categoriesWithModifiedBaseData.add(action.categoryId)

src/function/sync/apply-actions/dispatch-parent-action/updatecategorydisablelimits.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -36,12 +36,12 @@ export async function dispatchUpdateCategoryDisableLimits ({ action, cache, from
     }
   }
 
-  const categoryEntryUnsafe = await cache.database.category.findOne({
+  const categoryEntryUnsafe = await cache.transaction.legacy.database.category.findOne({
     where: {
       familyId: cache.familyId,
       categoryId: action.categoryId
     },
-    transaction: cache.transaction,
+    transaction: cache.transaction.legacy.transaction,
     attributes: ['childId']
   })
 
@@ -59,14 +59,14 @@ export async function dispatchUpdateCategoryDisableLimits ({ action, cache, from
     }
   }
 
-  const [affectedRows] = await cache.database.category.update({
+  const [affectedRows] = await cache.transaction.legacy.database.category.update({
     disableLimitsUntil: action.endTime.toString(10)
   }, {
     where: {
       familyId: cache.familyId,
       categoryId: action.categoryId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (affectedRows !== 0) {

src/function/sync/apply-actions/dispatch-parent-action/updatecategoryflags.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -24,12 +24,12 @@ export async function dispatchUpdateCategoryFlagsAction ({ action, cache }: {
   action: UpdateCategoryFlagsAction
   cache: Cache
 }) {
-  const categoryEntry = await cache.database.category.findOne({
+  const categoryEntry = await cache.transaction.legacy.database.category.findOne({
     where: {
       familyId: cache.familyId,
       categoryId: action.categoryId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (!categoryEntry) {
@@ -46,7 +46,7 @@ export async function dispatchUpdateCategoryFlagsAction ({ action, cache }: {
 
   categoryEntry.flags = newFlags.toString(10)
 
-  await categoryEntry.save({ transaction: cache.transaction })
+  await categoryEntry.save({ transaction: cache.transaction.legacy.transaction })
 
   cache.categoriesWithModifiedBaseData.add(action.categoryId)
   cache.incrementTriggeredSyncLevel(2)

src/function/sync/apply-actions/dispatch-parent-action/updatecategorysorting.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -30,10 +30,10 @@ export async function dispatchUpdateCategorySorting ({ action, cache }: {
   for (let i = 0; i < action.categoryIds.length; i++) {
     const categoryId = action.categoryIds[i]
 
-    await cache.database.category.update({
+    await cache.transaction.legacy.database.category.update({
       sort: i
     }, {
-      transaction: cache.transaction,
+      transaction: cache.transaction.legacy.transaction,
       where: {
         familyId: cache.familyId,
         categoryId

src/function/sync/apply-actions/dispatch-parent-action/updatecategorytemporarilyblocked.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -32,12 +32,12 @@ export async function dispatchUpdateCategoryTemporarilyBlocked ({ action, cache,
     }
   }
 
-  const categoryEntryUnsafe = await cache.database.category.findOne({
+  const categoryEntryUnsafe = await cache.transaction.legacy.database.category.findOne({
     where: {
       familyId: cache.familyId,
       categoryId: action.categoryId
     },
-    transaction: cache.transaction,
+    transaction: cache.transaction.legacy.transaction,
     attributes: ['childId', 'temporarilyBlocked', 'temporarilyBlockedEndTime']
   })
 
@@ -67,7 +67,7 @@ export async function dispatchUpdateCategoryTemporarilyBlocked ({ action, cache,
     }
   }
 
-  const [affectedRows] = await cache.database.category.update({
+  const [affectedRows] = await cache.transaction.legacy.database.category.update({
     temporarilyBlocked: action.blocked,
     temporarilyBlockedEndTime: action.blocked ? (action.endTime ?? 0).toString(10) : '0'
   }, {
@@ -75,7 +75,7 @@ export async function dispatchUpdateCategoryTemporarilyBlocked ({ action, cache,
       familyId: cache.familyId,
       categoryId: action.categoryId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (affectedRows !== 0) {

src/function/sync/apply-actions/dispatch-parent-action/updatecategorytimewarnings.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -23,12 +23,12 @@ export async function dispatchUpdateCategoryTimeWarnings ({ action, cache }: {
   action: UpdateCategoryTimeWarningsAction
   cache: Cache
 }) {
-  const categoryEntry = await cache.database.category.findOne({
+  const categoryEntry = await cache.transaction.legacy.database.category.findOne({
     where: {
       familyId: cache.familyId,
       categoryId: action.categoryId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (!categoryEntry) {
@@ -41,26 +41,26 @@ export async function dispatchUpdateCategoryTimeWarnings ({ action, cache }: {
     categoryEntry.timeWarningFlags &= ~action.flags
   }
 
-  await categoryEntry.save({ transaction: cache.transaction })
+  await categoryEntry.save({ transaction: cache.transaction.legacy.transaction })
 
   if (action.minutes !== undefined) {
     if (action.enable) {
-      await cache.database.categoryTimeWarning.create({
+      await cache.transaction.legacy.database.categoryTimeWarning.create({
         familyId: cache.familyId,
         categoryId: action.categoryId,
         minutes: action.minutes
       }, {
-        transaction: cache.transaction,
+        transaction: cache.transaction.legacy.transaction,
         ignoreDuplicates: true
       })
     } else {
-      await cache.database.categoryTimeWarning.destroy({
+      await cache.transaction.legacy.database.categoryTimeWarning.destroy({
         where: {
           familyId: cache.familyId,
           categoryId: action.categoryId,
           minutes: action.minutes
         },
-        transaction: cache.transaction
+        transaction: cache.transaction.legacy.transaction
       })
     }
   }

src/function/sync/apply-actions/dispatch-parent-action/updatecategorytitle.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -23,26 +23,26 @@ export async function dispatchUpdateCategoryTitle ({ action, cache }: {
   action: UpdateCategoryTitleAction
   cache: Cache
 }) {
-  const oldCategory = await cache.database.category.findOne({
+  const oldCategory = await cache.transaction.legacy.database.category.findOne({
     where: {
       familyId: cache.familyId,
       categoryId: action.categoryId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (!oldCategory) {
     throw new MissingCategoryException()
   }
 
-  const [affectedRows] = await cache.database.category.update({
+  const [affectedRows] = await cache.transaction.legacy.database.category.update({
     title: action.newTitle
   }, {
     where: {
       familyId: cache.familyId,
       categoryId: action.categoryId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (affectedRows !== 0) {

src/function/sync/apply-actions/dispatch-parent-action/updatechildtaskaction.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -24,23 +24,23 @@ export async function dispatchUpdateChildTaskAction ({ action, cache }: {
   action: UpdateChildTaskAction
   cache: Cache
 }) {
-  const categoryInfoUnsafe = await cache.database.category.findOne({
+  const categoryInfoUnsafe = await cache.transaction.legacy.database.category.findOne({
     where: {
       familyId: cache.familyId,
       categoryId: action.categoryId
     },
     attributes: ['childId'],
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (categoryInfoUnsafe === null) throw new MissingCategoryException()
 
-  const taskInfo = await cache.database.childTask.findOne({
+  const taskInfo = await cache.transaction.legacy.database.childTask.findOne({
     where: {
       familyId: cache.familyId,
       taskId: action.taskId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   const notFound = taskInfo === null
@@ -56,7 +56,7 @@ export async function dispatchUpdateChildTaskAction ({ action, cache }: {
   }
 
   if (taskInfo === null) {
-    await cache.database.childTask.create({
+    await cache.transaction.legacy.database.childTask.create({
       familyId: cache.familyId,
       taskId: action.taskId,
       categoryId: action.categoryId,
@@ -65,12 +65,12 @@ export async function dispatchUpdateChildTaskAction ({ action, cache }: {
       pendingRequest: 0,
       lastGrantTimestamp: '0'
     }, {
-      transaction: cache.transaction
+      transaction: cache.transaction.legacy.transaction
     })
 
     cache.categoriesWithModifiedTasks.add(action.categoryId)
   } else {
-    await cache.database.childTask.update({
+    await cache.transaction.legacy.database.childTask.update({
       taskTitle: action.taskTitle,
       categoryId: action.categoryId,
       extraTimeDuration: action.extraTimeDuration
@@ -79,7 +79,7 @@ export async function dispatchUpdateChildTaskAction ({ action, cache }: {
         familyId: cache.familyId,
         taskId: action.taskId
       },
-      transaction: cache.transaction
+      transaction: cache.transaction.legacy.transaction
     })
 
     cache.categoriesWithModifiedTasks.add(taskInfo.categoryId)

src/function/sync/apply-actions/dispatch-parent-action/updatedevicename.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -23,26 +23,26 @@ export async function dispatchUpdateDeviceName ({ action, cache }: {
   action: UpdateDeviceNameAction
   cache: Cache
 }) {
-  const oldDevice = await cache.database.device.findOne({
+  const oldDevice = await cache.transaction.legacy.database.device.findOne({
     where: {
       familyId: cache.familyId,
       deviceId: action.deviceId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (!oldDevice) {
     throw new MissingDeviceException()
   }
 
-  const [affectedRows] = await cache.database.device.update({
+  const [affectedRows] = await cache.transaction.legacy.database.device.update({
     name: action.name
   }, {
     where: {
       familyId: cache.familyId,
       deviceId: action.deviceId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (affectedRows !== 0) {

src/function/sync/apply-actions/dispatch-parent-action/updateenableactivitylevelblocking.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -23,8 +23,8 @@ export async function dispatchUpdateEnableActivityLevelBlocking ({ action, cache
   action: UpdateEnableActivityLevelBlockingAction
   cache: Cache
 }) {
-  const oldDevice = await cache.database.device.findOne({
+  const oldDevice = await cache.transaction.legacy.database.device.findOne({
-    transaction: cache.transaction,
+    transaction: cache.transaction.legacy.transaction,
     where: {
       familyId: cache.familyId,
       deviceId: action.deviceId
@@ -35,10 +35,10 @@ export async function dispatchUpdateEnableActivityLevelBlocking ({ action, cache
     throw new MissingDeviceException()
   }
 
-  await cache.database.device.update({
+  await cache.transaction.legacy.database.device.update({
     activityLevelBlocking: action.enable
   }, {
-    transaction: cache.transaction,
+    transaction: cache.transaction.legacy.transaction,
     where: {
       familyId: cache.familyId,
       deviceId: action.deviceId

src/function/sync/apply-actions/dispatch-parent-action/updatenetworktimeverification.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -23,8 +23,8 @@ export async function dispatchUpdateNetworkTimeVerification ({ action, cache }:
   action: UpdateNetworkTimeVerificationAction
   cache: Cache
 }) {
-  const oldDevice = await cache.database.device.findOne({
+  const oldDevice = await cache.transaction.legacy.database.device.findOne({
-    transaction: cache.transaction,
+    transaction: cache.transaction.legacy.transaction,
     where: {
       familyId: cache.familyId,
       deviceId: action.deviceId
@@ -35,14 +35,14 @@ export async function dispatchUpdateNetworkTimeVerification ({ action, cache }:
     throw new MissingDeviceException()
   }
 
-  await cache.database.device.update({
+  await cache.transaction.legacy.database.device.update({
     networkTime: action.mode
   }, {
     where: {
       familyId: cache.familyId,
       deviceId: action.deviceId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   cache.invalidiateDeviceList = true

src/function/sync/apply-actions/dispatch-parent-action/updateparentnotificationflags.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -23,13 +23,13 @@ export async function dispatchUpdateParentNotificationFlags ({ action, cache }:
   action: UpdateParentNotificationFlagsAction
   cache: Cache
 }) {
-  const parentEntry = await cache.database.user.findOne({
+  const parentEntry = await cache.transaction.legacy.database.user.findOne({
     where: {
       familyId: cache.familyId,
       userId: action.parentId,
       type: 'parent'
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (!parentEntry) {
@@ -42,7 +42,7 @@ export async function dispatchUpdateParentNotificationFlags ({ action, cache }:
     parentEntry.mailNotificationFlags &= ~action.flags
   }
 
-  await parentEntry.save({ transaction: cache.transaction })
+  await parentEntry.save({ transaction: cache.transaction.legacy.transaction })
 
   cache.invalidiateUserList = true
   cache.incrementTriggeredSyncLevel(1)

src/function/sync/apply-actions/dispatch-parent-action/updatetimelimitrule.ts

@@ -29,12 +29,12 @@ export async function dispatchUpdateTimelimitRule ({
   cache: Cache
   fromChildSelfLimitAddChildUserId: string | null
 }) {
-  const ruleEntry = await cache.database.timelimitRule.findOne({
+  const ruleEntry = await cache.transaction.legacy.database.timelimitRule.findOne({
     where: {
       familyId: cache.familyId,
       ruleId: action.ruleId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (!ruleEntry) {
@@ -42,12 +42,12 @@ export async function dispatchUpdateTimelimitRule ({
   }
 
   if (fromChildSelfLimitAddChildUserId != null) {
-    const categoryEntryUnsafe = await cache.database.category.findOne({
+    const categoryEntryUnsafe = await cache.transaction.legacy.database.category.findOne({
       where: {
         familyId: cache.familyId,
         categoryId: ruleEntry.categoryId
       },
-      transaction: cache.transaction,
+      transaction: cache.transaction.legacy.transaction,
       attributes: ['childId']
     })
 
@@ -103,7 +103,7 @@ export async function dispatchUpdateTimelimitRule ({
   ruleEntry.perDay = action.perDay ? 1 : 0
   ruleEntry.expiresAt = action.expiresAt ? action.expiresAt.toString() : null
 
-  await ruleEntry.save({ transaction: cache.transaction })
+  await ruleEntry.save({ transaction: cache.transaction.legacy.transaction })
 
   cache.categoriesWithModifiedTimeLimitRules.add(ruleEntry.categoryId)
   cache.incrementTriggeredSyncLevel(2)

src/function/sync/apply-actions/dispatch-parent-action/updateuserflags.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -24,12 +24,12 @@ export async function dispatchUpdateUserFlagsAction ({ action, cache }: {
   action: UpdateUserFlagsAction
   cache: Cache
 }) {
-  const userEntry = await cache.database.user.findOne({
+  const userEntry = await cache.transaction.legacy.database.user.findOne({
     where: {
       familyId: cache.familyId,
       userId: action.userId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (!userEntry) {
@@ -46,7 +46,7 @@ export async function dispatchUpdateUserFlagsAction ({ action, cache }: {
 
   userEntry.flags = newFlags.toString(10)
 
-  await userEntry.save({ transaction: cache.transaction })
+  await userEntry.save({ transaction: cache.transaction.legacy.transaction })
 
   cache.invalidiateUserList = true
   cache.incrementTriggeredSyncLevel(1)

src/function/sync/apply-actions/dispatch-parent-action/updateuserlimitlogincategory.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -25,13 +25,13 @@ export async function dispatchUpdateUserLimitLoginCategoryAction ({ action, cach
   cache: Cache
   parentUserId: string
 }) {
-  const userEntry = await cache.database.user.findOne({
+  const userEntry = await cache.transaction.legacy.database.user.findOne({
     where: {
       familyId: cache.familyId,
       userId: action.userId,
       type: 'parent'
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (!userEntry) {
@@ -44,34 +44,34 @@ export async function dispatchUpdateUserLimitLoginCategoryAction ({ action, cach
     })
   }
 
-  await cache.database.userLimitLoginCategory.destroy({
+  await cache.transaction.legacy.database.userLimitLoginCategory.destroy({
     where: {
       familyId: cache.familyId,
       userId: action.userId
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (action.categoryId !== undefined) {
-    const categoryEntry = await cache.database.category.findOne({
+    const categoryEntry = await cache.transaction.legacy.database.category.findOne({
       where: {
         familyId: cache.familyId,
         categoryId: action.categoryId
       },
-      transaction: cache.transaction
+      transaction: cache.transaction.legacy.transaction
     })
 
     if (!categoryEntry) {
       throw new MissingCategoryException()
     }
 
-    await cache.database.userLimitLoginCategory.create({
+    await cache.transaction.legacy.database.userLimitLoginCategory.create({
       familyId: cache.familyId,
       userId: action.userId,
       categoryId: action.categoryId,
       preBlockDuration: 0
     }, {
-      transaction: cache.transaction
+      transaction: cache.transaction.legacy.transaction
     })
   }
 

src/function/sync/apply-actions/dispatch-parent-action/updateuserlimitloginpreblockduration.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -25,13 +25,13 @@ export async function dispatchUpdateUserLimitPreBlockDuration ({ action, cache,
   cache: Cache
   parentUserId: string
 }) {
-  const userEntry = await cache.database.user.findOne({
+  const userEntry = await cache.transaction.legacy.database.user.findOne({
     where: {
       familyId: cache.familyId,
       userId: action.userId,
       type: 'parent'
     },
-    transaction: cache.transaction
+    transaction: cache.transaction.legacy.transaction
   })
 
   if (!userEntry) {
@@ -44,8 +44,8 @@ export async function dispatchUpdateUserLimitPreBlockDuration ({ action, cache,
     })
   }
 
-  const preBlockItem = await cache.database.userLimitLoginCategory.findOne({
+  const preBlockItem = await cache.transaction.legacy.database.userLimitLoginCategory.findOne({
-    transaction: cache.transaction,
+    transaction: cache.transaction.legacy.transaction,
     where: {
       familyId: cache.familyId,
       userId: action.userId
@@ -58,10 +58,10 @@ export async function dispatchUpdateUserLimitPreBlockDuration ({ action, cache,
     })
   }
 
-  await cache.database.userLimitLoginCategory.update({
+  await cache.transaction.legacy.database.userLimitLoginCategory.update({
     preBlockDuration: action.preBlockDuration
   }, {
-    transaction: cache.transaction,
+    transaction: cache.transaction.legacy.transaction,
     where: {
       familyId: cache.familyId,
       userId: action.userId

src/function/sync/apply-actions/index.ts

@@ -1,6 +1,6 @@
 /*
  * server component for the TimeLimit App
- * Copyright (C) 2019 - 2022 Jonas Lochmann
+ * Copyright (C) 2019 - 2026 Jonas Lochmann
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
@@ -18,7 +18,8 @@
 import { BadRequest } from 'http-errors'
 import { ClientPushChangesRequest } from '../../../api/schema'
 import { VisibleConnectedDevicesManager } from '../../../connected-devices'
-import { Database, shouldRetryWithException } from '../../../database'
+import { SimpleDatabase } from '../../../database/simple'
+import { shouldRetryWithException } from '../../../database'
 import { EventHandler } from '../../../monitoring/eventhandler'
 import { WebsocketApi } from '../../../websocket'
 import { notifyClientsAboutChangesDelayed } from '../../websocket'
@@ -31,7 +32,7 @@ import { SequenceNumberRepeatedException } from './exception/sequence'
 import { assertActionIntegrity } from './integrity'
 
 export const applyActionsFromDevice = async ({ database, request, websocket, connectedDevicesManager, eventHandler }: {
-  database: Database
+  database: SimpleDatabase
   websocket: WebsocketApi
   request: ClientPushChangesRequest
   connectedDevicesManager: VisibleConnectedDevicesManager
@@ -47,12 +48,11 @@ export const applyActionsFromDevice = async ({ database, request, websocket, con
   }
 
   return database.transaction(async (transaction) => {
-    const baseInfo = await getApplyActionBaseInfo({ database, transaction, deviceAuthToken: request.deviceAuthToken })
+    const baseInfo = await getApplyActionBaseInfo({ transaction, deviceAuthToken: request.deviceAuthToken })
 
     const cache = new Cache({
-      database,
-      hasFullVersion: baseInfo.hasFullVersion,
       transaction,
+      hasFullVersion: baseInfo.hasFullVersion,
       familyId: baseInfo.familyId,
       deviceId: baseInfo.deviceId,
       connectedDevicesManager
@@ -112,7 +112,7 @@ export const applyActionsFromDevice = async ({ database, request, websocket, con
           }
         })
       } catch (ex) {
-        if (shouldRetryWithException(database, ex)) {
+        if (shouldRetryWithException(transaction.legacy.database, ex)) {
           eventHandler.countEvent('applyActionsFromDevice got exception which should cause retry')
 
           throw ex
@@ -132,14 +132,14 @@ export const applyActionsFromDevice = async ({ database, request, websocket, con
     if (nextSequenceNumber !== baseInfo.nextSequenceNumber) {
       eventHandler.countEvent('applyActionsFromDevice updateSequenceNumber')
 
-      await database.device.update({
+      await transaction.legacy.database.device.update({
         nextSequenceNumber
       }, {
         where: {
           familyId: baseInfo.familyId,
           deviceId: baseInfo.deviceId
         },
-        transaction
+        transaction: transaction.legacy.transaction
       })
     }
 
@@ -149,18 +149,17 @@ export const applyActionsFromDevice = async ({ database, request, websocket, con
       familyId: baseInfo.familyId,
       sourceDeviceId: baseInfo.deviceId,
       websocket,
-      database,
       transaction,
       generalLevel: cache.triggeredSyncLevel,
       targetedLevels: cache.targetedTriggeredSyncLevels
     })
 
     if (cache.triggeredSyncLevel === 2) {
-      transaction.afterCommit(() => {
+      transaction.enqueueAfterCommit(() => {
         eventHandler.countEvent('applyActionsFromDevice areChangesImportant')
       })
     } else if ([...cache.targetedTriggeredSyncLevels.entries()].some((entry) => entry[1] === 2)) {
-      transaction.afterCommit(() => {
+      transaction.enqueueAfterCommit(() => {
         eventHandler.countEvent('applyActionsFromDevice areChangesImportantTargeted')
       })
     }