feat: rename schema (#19891)

2025-07-14 10:13:06 -04:00
parent 33c29e4305
commit c699df002a
103 changed files with 4378 additions and 3224 deletions
@@ -7,27 +7,27 @@ import { DB } from 'src/schema';
 import { SyncAck } from 'src/types';

 type AuditTables =
-  | 'users_audit'
-  | 'partners_audit'
-  | 'assets_audit'
-  | 'albums_audit'
-  | 'album_users_audit'
-  | 'album_assets_audit'
-  | 'memories_audit'
-  | 'memory_assets_audit'
-  | 'stacks_audit'
+  | 'user_audit'
+  | 'partner_audit'
+  | 'asset_audit'
+  | 'album_audit'
+  | 'album_user_audit'
+  | 'album_asset_audit'
+  | 'memory_audit'
+  | 'memory_asset_audit'
+  | 'stack_audit'
  | 'person_audit'
  | 'user_metadata_audit';
 type UpsertTables =
-  | 'users'
-  | 'partners'
-  | 'assets'
-  | 'exif'
-  | 'albums'
-  | 'albums_shared_users_users'
-  | 'memories'
-  | 'memories_assets_assets'
-  | 'asset_stack'
+  | 'user'
+  | 'partner'
+  | 'asset'
+  | 'asset_exif'
+  | 'album'
+  | 'album_user'
+  | 'memory'
+  | 'memory_asset'
+  | 'stack'
  | 'person'
  | 'user_metadata';

@@ -100,7 +100,7 @@ class AlbumSync extends BaseSync {
  @GenerateSql({ params: [DummyValue.UUID, DummyValue.UUID] })
  getCreatedAfter(userId: string, afterCreateId?: string) {
    return this.db
-      .selectFrom('albums_shared_users_users')
+      .selectFrom('album_user')
      .select(['albumsId as id', 'createId'])
      .where('usersId', '=', userId)
      .$if(!!afterCreateId, (qb) => qb.where('createId', '>=', afterCreateId!))
@@ -112,7 +112,7 @@ class AlbumSync extends BaseSync {
  @GenerateSql({ params: [DummyValue.UUID], stream: true })
  getDeletes(userId: string, ack?: SyncAck) {
    return this.db
-      .selectFrom('albums_audit')
+      .selectFrom('album_audit')
      .select(['id', 'albumId'])
      .where('userId', '=', userId)
      .$call(this.auditTableFilters(ack))
@@ -122,24 +122,24 @@ class AlbumSync extends BaseSync {
  @GenerateSql({ params: [DummyValue.UUID], stream: true })
  getUpserts(userId: string, ack?: SyncAck) {
    return this.db
-      .selectFrom('albums')
-      .distinctOn(['albums.id', 'albums.updateId'])
-      .where('albums.updatedAt', '<', sql.raw<Date>("now() - interval '1 millisecond'"))
-      .$if(!!ack, (qb) => qb.where('albums.updateId', '>', ack!.updateId))
-      .orderBy('albums.updateId', 'asc')
-      .leftJoin('albums_shared_users_users as album_users', 'albums.id', 'album_users.albumsId')
-      .where((eb) => eb.or([eb('albums.ownerId', '=', userId), eb('album_users.usersId', '=', userId)]))
+      .selectFrom('album')
+      .distinctOn(['album.id', 'album.updateId'])
+      .where('album.updatedAt', '<', sql.raw<Date>("now() - interval '1 millisecond'"))
+      .$if(!!ack, (qb) => qb.where('album.updateId', '>', ack!.updateId))
+      .orderBy('album.updateId', 'asc')
+      .leftJoin('album_user as album_users', 'album.id', 'album_users.albumsId')
+      .where((eb) => eb.or([eb('album.ownerId', '=', userId), eb('album_users.usersId', '=', userId)]))
      .select([
-        'albums.id',
-        'albums.ownerId',
-        'albums.albumName as name',
-        'albums.description',
-        'albums.createdAt',
-        'albums.updatedAt',
-        'albums.albumThumbnailAssetId as thumbnailAssetId',
-        'albums.isActivityEnabled',
-        'albums.order',
-        'albums.updateId',
+        'album.id',
+        'album.ownerId',
+        'album.albumName as name',
+        'album.description',
+        'album.createdAt',
+        'album.updatedAt',
+        'album.albumThumbnailAssetId as thumbnailAssetId',
+        'album.isActivityEnabled',
+        'album.order',
+        'album.updateId',
      ])
      .stream();
  }
@@ -149,31 +149,31 @@ class AlbumAssetSync extends BaseSync {
  @GenerateSql({ params: [DummyValue.UUID, DummyValue.UUID, DummyValue.UUID], stream: true })
  getBackfill(albumId: string, afterUpdateId: string | undefined, beforeUpdateId: string) {
    return this.db
-      .selectFrom('assets')
-      .innerJoin('albums_assets_assets as album_assets', 'album_assets.assetsId', 'assets.id')
+      .selectFrom('asset')
+      .innerJoin('album_asset', 'album_asset.assetsId', 'asset.id')
      .select(columns.syncAsset)
-      .select('assets.updateId')
-      .where('album_assets.albumsId', '=', albumId)
-      .where('assets.updatedAt', '<', sql.raw<Date>("now() - interval '1 millisecond'"))
-      .where('assets.updateId', '<=', beforeUpdateId)
-      .$if(!!afterUpdateId, (eb) => eb.where('assets.updateId', '>=', afterUpdateId!))
-      .orderBy('assets.updateId', 'asc')
+      .select('asset.updateId')
+      .where('album_asset.albumsId', '=', albumId)
+      .where('asset.updatedAt', '<', sql.raw<Date>("now() - interval '1 millisecond'"))
+      .where('asset.updateId', '<=', beforeUpdateId)
+      .$if(!!afterUpdateId, (eb) => eb.where('asset.updateId', '>=', afterUpdateId!))
+      .orderBy('asset.updateId', 'asc')
      .stream();
  }

  @GenerateSql({ params: [DummyValue.UUID], stream: true })
  getUpserts(userId: string, ack?: SyncAck) {
    return this.db
-      .selectFrom('assets')
-      .innerJoin('albums_assets_assets as album_assets', 'album_assets.assetsId', 'assets.id')
+      .selectFrom('asset')
+      .innerJoin('album_asset', 'album_asset.assetsId', 'asset.id')
      .select(columns.syncAsset)
-      .select('assets.updateId')
-      .where('assets.updatedAt', '<', sql.raw<Date>("now() - interval '1 millisecond'"))
-      .$if(!!ack, (qb) => qb.where('assets.updateId', '>', ack!.updateId))
-      .orderBy('assets.updateId', 'asc')
-      .innerJoin('albums', 'albums.id', 'album_assets.albumsId')
-      .leftJoin('albums_shared_users_users as album_users', 'album_users.albumsId', 'album_assets.albumsId')
-      .where((eb) => eb.or([eb('albums.ownerId', '=', userId), eb('album_users.usersId', '=', userId)]))
+      .select('asset.updateId')
+      .where('asset.updatedAt', '<', sql.raw<Date>("now() - interval '1 millisecond'"))
+      .$if(!!ack, (qb) => qb.where('asset.updateId', '>', ack!.updateId))
+      .orderBy('asset.updateId', 'asc')
+      .innerJoin('album', 'album.id', 'album_asset.albumsId')
+      .leftJoin('album_user', 'album_user.albumsId', 'album_asset.albumsId')
+      .where((eb) => eb.or([eb('album.ownerId', '=', userId), eb('album_user.usersId', '=', userId)]))
      .stream();
  }
 }
@@ -182,31 +182,31 @@ class AlbumAssetExifSync extends BaseSync {
  @GenerateSql({ params: [DummyValue.UUID, DummyValue.UUID, DummyValue.UUID], stream: true })
  getBackfill(albumId: string, afterUpdateId: string | undefined, beforeUpdateId: string) {
    return this.db
-      .selectFrom('exif')
-      .innerJoin('albums_assets_assets as album_assets', 'album_assets.assetsId', 'exif.assetId')
+      .selectFrom('asset_exif')
+      .innerJoin('album_asset', 'album_asset.assetsId', 'asset_exif.assetId')
      .select(columns.syncAssetExif)
-      .select('exif.updateId')
-      .where('album_assets.albumsId', '=', albumId)
-      .where('exif.updatedAt', '<', sql.raw<Date>("now() - interval '1 millisecond'"))
-      .where('exif.updateId', '<=', beforeUpdateId)
-      .$if(!!afterUpdateId, (eb) => eb.where('exif.updateId', '>=', afterUpdateId!))
-      .orderBy('exif.updateId', 'asc')
+      .select('asset_exif.updateId')
+      .where('album_asset.albumsId', '=', albumId)
+      .where('asset_exif.updatedAt', '<', sql.raw<Date>("now() - interval '1 millisecond'"))
+      .where('asset_exif.updateId', '<=', beforeUpdateId)
+      .$if(!!afterUpdateId, (eb) => eb.where('asset_exif.updateId', '>=', afterUpdateId!))
+      .orderBy('asset_exif.updateId', 'asc')
      .stream();
  }

  @GenerateSql({ params: [DummyValue.UUID], stream: true })
  getUpserts(userId: string, ack?: SyncAck) {
    return this.db
-      .selectFrom('exif')
-      .innerJoin('albums_assets_assets as album_assets', 'album_assets.assetsId', 'exif.assetId')
+      .selectFrom('asset_exif')
+      .innerJoin('album_asset', 'album_asset.assetsId', 'asset_exif.assetId')
      .select(columns.syncAssetExif)
-      .select('exif.updateId')
-      .where('exif.updatedAt', '<', sql.raw<Date>("now() - interval '1 millisecond'"))
-      .$if(!!ack, (qb) => qb.where('exif.updateId', '>', ack!.updateId))
-      .orderBy('exif.updateId', 'asc')
-      .innerJoin('albums', 'albums.id', 'album_assets.albumsId')
-      .leftJoin('albums_shared_users_users as album_users', 'album_users.albumsId', 'album_assets.albumsId')
-      .where((eb) => eb.or([eb('albums.ownerId', '=', userId), eb('album_users.usersId', '=', userId)]))
+      .select('asset_exif.updateId')
+      .where('asset_exif.updatedAt', '<', sql.raw<Date>("now() - interval '1 millisecond'"))
+      .$if(!!ack, (qb) => qb.where('asset_exif.updateId', '>', ack!.updateId))
+      .orderBy('asset_exif.updateId', 'asc')
+      .innerJoin('album', 'album.id', 'album_asset.albumsId')
+      .leftJoin('album_user', 'album_user.albumsId', 'album_asset.albumsId')
+      .where((eb) => eb.or([eb('album.ownerId', '=', userId), eb('album_user.usersId', '=', userId)]))
      .stream();
  }
 }
@@ -215,7 +215,7 @@ class AlbumToAssetSync extends BaseSync {
  @GenerateSql({ params: [DummyValue.UUID, DummyValue.UUID, DummyValue.UUID], stream: true })
  getBackfill(albumId: string, afterUpdateId: string | undefined, beforeUpdateId: string) {
    return this.db
-      .selectFrom('albums_assets_assets as album_assets')
+      .selectFrom('album_asset as album_assets')
      .select(['album_assets.assetsId as assetId', 'album_assets.albumsId as albumId', 'album_assets.updateId'])
      .where('album_assets.albumsId', '=', albumId)
      .where('album_assets.updatedAt', '<', sql.raw<Date>("now() - interval '1 millisecond'"))
@@ -228,22 +228,22 @@ class AlbumToAssetSync extends BaseSync {
  @GenerateSql({ params: [DummyValue.UUID], stream: true })
  getDeletes(userId: string, ack?: SyncAck) {
    return this.db
-      .selectFrom('album_assets_audit')
+      .selectFrom('album_asset_audit')
      .select(['id', 'assetId', 'albumId'])
      .where((eb) =>
        eb(
          'albumId',
          'in',
          eb
-            .selectFrom('albums')
+            .selectFrom('album')
            .select(['id'])
            .where('ownerId', '=', userId)
            .union((eb) =>
              eb.parens(
                eb
-                  .selectFrom('albums_shared_users_users as albumUsers')
-                  .select(['albumUsers.albumsId as id'])
-                  .where('albumUsers.usersId', '=', userId),
+                  .selectFrom('album_user')
+                  .select(['album_user.albumsId as id'])
+                  .where('album_user.usersId', '=', userId),
              ),
            ),
        ),
@@ -255,14 +255,14 @@ class AlbumToAssetSync extends BaseSync {
  @GenerateSql({ params: [DummyValue.UUID], stream: true })
  getUpserts(userId: string, ack?: SyncAck) {
    return this.db
-      .selectFrom('albums_assets_assets as album_assets')
-      .select(['album_assets.assetsId as assetId', 'album_assets.albumsId as albumId', 'album_assets.updateId'])
-      .where('album_assets.updatedAt', '<', sql.raw<Date>("now() - interval '1 millisecond'"))
-      .$if(!!ack, (qb) => qb.where('album_assets.updateId', '>', ack!.updateId))
-      .orderBy('album_assets.updateId', 'asc')
-      .innerJoin('albums', 'albums.id', 'album_assets.albumsId')
-      .leftJoin('albums_shared_users_users as album_users', 'album_users.albumsId', 'album_assets.albumsId')
-      .where((eb) => eb.or([eb('albums.ownerId', '=', userId), eb('album_users.usersId', '=', userId)]))
+      .selectFrom('album_asset')
+      .select(['album_asset.assetsId as assetId', 'album_asset.albumsId as albumId', 'album_asset.updateId'])
+      .where('album_asset.updatedAt', '<', sql.raw<Date>("now() - interval '1 millisecond'"))
+      .$if(!!ack, (qb) => qb.where('album_asset.updateId', '>', ack!.updateId))
+      .orderBy('album_asset.updateId', 'asc')
+      .innerJoin('album', 'album.id', 'album_asset.albumsId')
+      .leftJoin('album_user', 'album_user.albumsId', 'album_asset.albumsId')
+      .where((eb) => eb.or([eb('album.ownerId', '=', userId), eb('album_user.usersId', '=', userId)]))
      .stream();
  }
 }
@@ -271,9 +271,9 @@ class AlbumUserSync extends BaseSync {
  @GenerateSql({ params: [DummyValue.UUID, DummyValue.UUID, DummyValue.UUID, DummyValue.UUID], stream: true })
  getBackfill(albumId: string, afterUpdateId: string | undefined, beforeUpdateId: string) {
    return this.db
-      .selectFrom('albums_shared_users_users as album_users')
+      .selectFrom('album_user')
      .select(columns.syncAlbumUser)
-      .select('album_users.updateId')
+      .select('album_user.updateId')
      .where('albumsId', '=', albumId)
      .where('updatedAt', '<', sql.raw<Date>("now() - interval '1 millisecond'"))
      .where('updateId', '<=', beforeUpdateId)
@@ -285,22 +285,22 @@ class AlbumUserSync extends BaseSync {
  @GenerateSql({ params: [DummyValue.UUID], stream: true })
  getDeletes(userId: string, ack?: SyncAck) {
    return this.db
-      .selectFrom('album_users_audit')
+      .selectFrom('album_user_audit')
      .select(['id', 'userId', 'albumId'])
      .where((eb) =>
        eb(
          'albumId',
          'in',
          eb
-            .selectFrom('albums')
+            .selectFrom('album')
            .select(['id'])
            .where('ownerId', '=', userId)
            .union((eb) =>
              eb.parens(
                eb
-                  .selectFrom('albums_shared_users_users as albumUsers')
-                  .select(['albumUsers.albumsId as id'])
-                  .where('albumUsers.usersId', '=', userId),
+                  .selectFrom('album_user')
+                  .select(['album_user.albumsId as id'])
+                  .where('album_user.usersId', '=', userId),
              ),
            ),
        ),
@@ -312,24 +312,24 @@ class AlbumUserSync extends BaseSync {
  @GenerateSql({ params: [DummyValue.UUID], stream: true })
  getUpserts(userId: string, ack?: SyncAck) {
    return this.db
-      .selectFrom('albums_shared_users_users as album_users')
+      .selectFrom('album_user')
      .select(columns.syncAlbumUser)
-      .select('album_users.updateId')
-      .where('album_users.updatedAt', '<', sql.raw<Date>("now() - interval '1 millisecond'"))
-      .$if(!!ack, (qb) => qb.where('album_users.updateId', '>', ack!.updateId))
-      .orderBy('album_users.updateId', 'asc')
+      .select('album_user.updateId')
+      .where('album_user.updatedAt', '<', sql.raw<Date>("now() - interval '1 millisecond'"))
+      .$if(!!ack, (qb) => qb.where('album_user.updateId', '>', ack!.updateId))
+      .orderBy('album_user.updateId', 'asc')
      .where((eb) =>
        eb(
-          'album_users.albumsId',
+          'album_user.albumsId',
          'in',
          eb
-            .selectFrom('albums')
+            .selectFrom('album')
            .select(['id'])
            .where('ownerId', '=', userId)
            .union((eb) =>
              eb.parens(
                eb
-                  .selectFrom('albums_shared_users_users as albumUsers')
+                  .selectFrom('album_user as albumUsers')
                  .select(['albumUsers.albumsId as id'])
                  .where('albumUsers.usersId', '=', userId),
              ),
@@ -344,7 +344,7 @@ class AssetSync extends BaseSync {
  @GenerateSql({ params: [DummyValue.UUID], stream: true })
  getDeletes(userId: string, ack?: SyncAck) {
    return this.db
-      .selectFrom('assets_audit')
+      .selectFrom('asset_audit')
      .select(['id', 'assetId'])
      .where('ownerId', '=', userId)
      .$call(this.auditTableFilters(ack))
@@ -354,9 +354,9 @@ class AssetSync extends BaseSync {
  @GenerateSql({ params: [DummyValue.UUID], stream: true })
  getUpserts(userId: string, ack?: SyncAck) {
    return this.db
-      .selectFrom('assets')
+      .selectFrom('asset')
      .select(columns.syncAsset)
-      .select('assets.updateId')
+      .select('asset.updateId')
      .where('ownerId', '=', userId)
      .$call(this.upsertTableFilters(ack))
      .stream();
@@ -402,10 +402,10 @@ class AssetExifSync extends BaseSync {
  @GenerateSql({ params: [DummyValue.UUID], stream: true })
  getUpserts(userId: string, ack?: SyncAck) {
    return this.db
-      .selectFrom('exif')
+      .selectFrom('asset_exif')
      .select(columns.syncAssetExif)
-      .select('exif.updateId')
-      .where('assetId', 'in', (eb) => eb.selectFrom('assets').select('id').where('ownerId', '=', userId))
+      .select('asset_exif.updateId')
+      .where('assetId', 'in', (eb) => eb.selectFrom('asset').select('id').where('ownerId', '=', userId))
      .$call(this.upsertTableFilters(ack))
      .stream();
  }
@@ -415,7 +415,7 @@ class MemorySync extends BaseSync {
  @GenerateSql({ params: [DummyValue.UUID], stream: true })
  getDeletes(userId: string, ack?: SyncAck) {
    return this.db
-      .selectFrom('memories_audit')
+      .selectFrom('memory_audit')
      .select(['id', 'memoryId'])
      .where('userId', '=', userId)
      .$call(this.auditTableFilters(ack))
@@ -425,7 +425,7 @@ class MemorySync extends BaseSync {
  @GenerateSql({ params: [DummyValue.UUID], stream: true })
  getUpserts(userId: string, ack?: SyncAck) {
    return this.db
-      .selectFrom('memories')
+      .selectFrom('memory')
      .select([
        'id',
        'createdAt',
@@ -451,9 +451,9 @@ class MemoryToAssetSync extends BaseSync {
  @GenerateSql({ params: [DummyValue.UUID], stream: true })
  getDeletes(userId: string, ack?: SyncAck) {
    return this.db
-      .selectFrom('memory_assets_audit')
+      .selectFrom('memory_asset_audit')
      .select(['id', 'memoryId', 'assetId'])
-      .where('memoryId', 'in', (eb) => eb.selectFrom('memories').select('id').where('ownerId', '=', userId))
+      .where('memoryId', 'in', (eb) => eb.selectFrom('memory').select('id').where('ownerId', '=', userId))
      .$call(this.auditTableFilters(ack))
      .stream();
  }
@@ -461,10 +461,10 @@ class MemoryToAssetSync extends BaseSync {
  @GenerateSql({ params: [DummyValue.UUID], stream: true })
  getUpserts(userId: string, ack?: SyncAck) {
    return this.db
-      .selectFrom('memories_assets_assets')
+      .selectFrom('memory_asset')
      .select(['memoriesId as memoryId', 'assetsId as assetId'])
      .select('updateId')
-      .where('memoriesId', 'in', (eb) => eb.selectFrom('memories').select('id').where('ownerId', '=', userId))
+      .where('memoriesId', 'in', (eb) => eb.selectFrom('memory').select('id').where('ownerId', '=', userId))
      .$call(this.upsertTableFilters(ack))
      .stream();
  }
@@ -474,19 +474,19 @@ class PartnerSync extends BaseSync {
  @GenerateSql({ params: [DummyValue.UUID, DummyValue.UUID] })
  getCreatedAfter(userId: string, afterCreateId?: string) {
    return this.db
-      .selectFrom('partners')
+      .selectFrom('partner')
      .select(['sharedById', 'createId'])
      .where('sharedWithId', '=', userId)
      .$if(!!afterCreateId, (qb) => qb.where('createId', '>=', afterCreateId!))
      .where('createdAt', '<', sql.raw<Date>("now() - interval '1 millisecond'"))
-      .orderBy('partners.createId', 'asc')
+      .orderBy('partner.createId', 'asc')
      .execute();
  }

  @GenerateSql({ params: [DummyValue.UUID], stream: true })
  getDeletes(userId: string, ack?: SyncAck) {
    return this.db
-      .selectFrom('partners_audit')
+      .selectFrom('partner_audit')
      .select(['id', 'sharedById', 'sharedWithId'])
      .where((eb) => eb.or([eb('sharedById', '=', userId), eb('sharedWithId', '=', userId)]))
      .$call(this.auditTableFilters(ack))
@@ -496,7 +496,7 @@ class PartnerSync extends BaseSync {
  @GenerateSql({ params: [DummyValue.UUID], stream: true })
  getUpserts(userId: string, ack?: SyncAck) {
    return this.db
-      .selectFrom('partners')
+      .selectFrom('partner')
      .select(['sharedById', 'sharedWithId', 'inTimeline', 'updateId'])
      .where((eb) => eb.or([eb('sharedById', '=', userId), eb('sharedWithId', '=', userId)]))
      .$call(this.upsertTableFilters(ack))
@@ -508,9 +508,9 @@ class PartnerAssetsSync extends BaseSync {
  @GenerateSql({ params: [DummyValue.UUID, DummyValue.UUID, DummyValue.UUID], stream: true })
  getBackfill(partnerId: string, afterUpdateId: string | undefined, beforeUpdateId: string) {
    return this.db
-      .selectFrom('assets')
+      .selectFrom('asset')
      .select(columns.syncAsset)
-      .select('assets.updateId')
+      .select('asset.updateId')
      .where('ownerId', '=', partnerId)
      .where('updatedAt', '<', sql.raw<Date>("now() - interval '1 millisecond'"))
      .where('updateId', '<=', beforeUpdateId)
@@ -522,10 +522,10 @@ class PartnerAssetsSync extends BaseSync {
  @GenerateSql({ params: [DummyValue.UUID], stream: true })
  getDeletes(userId: string, ack?: SyncAck) {
    return this.db
-      .selectFrom('assets_audit')
+      .selectFrom('asset_audit')
      .select(['id', 'assetId'])
      .where('ownerId', 'in', (eb) =>
-        eb.selectFrom('partners').select(['sharedById']).where('sharedWithId', '=', userId),
+        eb.selectFrom('partner').select(['sharedById']).where('sharedWithId', '=', userId),
      )
      .$call(this.auditTableFilters(ack))
      .stream();
@@ -534,11 +534,11 @@ class PartnerAssetsSync extends BaseSync {
  @GenerateSql({ params: [DummyValue.UUID], stream: true })
  getUpserts(userId: string, ack?: SyncAck) {
    return this.db
-      .selectFrom('assets')
+      .selectFrom('asset')
      .select(columns.syncAsset)
-      .select('assets.updateId')
+      .select('asset.updateId')
      .where('ownerId', 'in', (eb) =>
-        eb.selectFrom('partners').select(['sharedById']).where('sharedWithId', '=', userId),
+        eb.selectFrom('partner').select(['sharedById']).where('sharedWithId', '=', userId),
      )
      .$call(this.upsertTableFilters(ack))
      .stream();
@@ -549,30 +549,30 @@ class PartnerAssetExifsSync extends BaseSync {
  @GenerateSql({ params: [DummyValue.UUID, DummyValue.UUID, DummyValue.UUID], stream: true })
  getBackfill(partnerId: string, afterUpdateId: string | undefined, beforeUpdateId: string) {
    return this.db
-      .selectFrom('exif')
+      .selectFrom('asset_exif')
      .select(columns.syncAssetExif)
-      .select('exif.updateId')
-      .innerJoin('assets', 'assets.id', 'exif.assetId')
-      .where('assets.ownerId', '=', partnerId)
-      .where('exif.updatedAt', '<', sql.raw<Date>("now() - interval '1 millisecond'"))
-      .where('exif.updateId', '<=', beforeUpdateId)
-      .$if(!!afterUpdateId, (eb) => eb.where('exif.updateId', '>=', afterUpdateId!))
-      .orderBy('exif.updateId', 'asc')
+      .select('asset_exif.updateId')
+      .innerJoin('asset', 'asset.id', 'asset_exif.assetId')
+      .where('asset.ownerId', '=', partnerId)
+      .where('asset_exif.updatedAt', '<', sql.raw<Date>("now() - interval '1 millisecond'"))
+      .where('asset_exif.updateId', '<=', beforeUpdateId)
+      .$if(!!afterUpdateId, (eb) => eb.where('asset_exif.updateId', '>=', afterUpdateId!))
+      .orderBy('asset_exif.updateId', 'asc')
      .stream();
  }

  @GenerateSql({ params: [DummyValue.UUID], stream: true })
  getUpserts(userId: string, ack?: SyncAck) {
    return this.db
-      .selectFrom('exif')
+      .selectFrom('asset_exif')
      .select(columns.syncAssetExif)
-      .select('exif.updateId')
+      .select('asset_exif.updateId')
      .where('assetId', 'in', (eb) =>
        eb
-          .selectFrom('assets')
+          .selectFrom('asset')
          .select('id')
          .where('ownerId', 'in', (eb) =>
-            eb.selectFrom('partners').select(['sharedById']).where('sharedWithId', '=', userId),
+            eb.selectFrom('partner').select(['sharedById']).where('sharedWithId', '=', userId),
          ),
      )
      .$call(this.upsertTableFilters(ack))
@@ -584,7 +584,7 @@ class StackSync extends BaseSync {
  @GenerateSql({ params: [DummyValue.UUID], stream: true })
  getDeletes(userId: string, ack?: SyncAck) {
    return this.db
-      .selectFrom('stacks_audit')
+      .selectFrom('stack_audit')
      .select(['id', 'stackId'])
      .where('userId', '=', userId)
      .$call(this.auditTableFilters(ack))
@@ -594,7 +594,7 @@ class StackSync extends BaseSync {
  @GenerateSql({ params: [DummyValue.UUID], stream: true })
  getUpserts(userId: string, ack?: SyncAck) {
    return this.db
-      .selectFrom('asset_stack')
+      .selectFrom('stack')
      .select(columns.syncStack)
      .select('updateId')
      .where('ownerId', '=', userId)
@@ -607,11 +607,9 @@ class PartnerStackSync extends BaseSync {
  @GenerateSql({ params: [DummyValue.UUID], stream: true })
  getDeletes(userId: string, ack?: SyncAck) {
    return this.db
-      .selectFrom('stacks_audit')
+      .selectFrom('stack_audit')
      .select(['id', 'stackId'])
-      .where('userId', 'in', (eb) =>
-        eb.selectFrom('partners').select(['sharedById']).where('sharedWithId', '=', userId),
-      )
+      .where('userId', 'in', (eb) => eb.selectFrom('partner').select(['sharedById']).where('sharedWithId', '=', userId))
      .$call(this.auditTableFilters(ack))
      .stream();
  }
@@ -619,7 +617,7 @@ class PartnerStackSync extends BaseSync {
  @GenerateSql({ params: [DummyValue.UUID, DummyValue.UUID, DummyValue.UUID], stream: true })
  getBackfill(partnerId: string, afterUpdateId: string | undefined, beforeUpdateId: string) {
    return this.db
-      .selectFrom('asset_stack')
+      .selectFrom('stack')
      .select(columns.syncStack)
      .select('updateId')
      .where('ownerId', '=', partnerId)
@@ -633,11 +631,11 @@ class PartnerStackSync extends BaseSync {
  @GenerateSql({ params: [DummyValue.UUID], stream: true })
  getUpserts(userId: string, ack?: SyncAck) {
    return this.db
-      .selectFrom('asset_stack')
+      .selectFrom('stack')
      .select(columns.syncStack)
      .select('updateId')
      .where('ownerId', 'in', (eb) =>
-        eb.selectFrom('partners').select(['sharedById']).where('sharedWithId', '=', userId),
+        eb.selectFrom('partner').select(['sharedById']).where('sharedWithId', '=', userId),
      )
      .$call(this.upsertTableFilters(ack))
      .stream();
@@ -647,13 +645,13 @@ class PartnerStackSync extends BaseSync {
 class UserSync extends BaseSync {
  @GenerateSql({ params: [], stream: true })
  getDeletes(ack?: SyncAck) {
-    return this.db.selectFrom('users_audit').select(['id', 'userId']).$call(this.auditTableFilters(ack)).stream();
+    return this.db.selectFrom('user_audit').select(['id', 'userId']).$call(this.auditTableFilters(ack)).stream();
  }

  @GenerateSql({ params: [], stream: true })
  getUpserts(ack?: SyncAck) {
    return this.db
-      .selectFrom('users')
+      .selectFrom('user')
      .select(['id', 'name', 'email', 'deletedAt', 'updateId'])
      .$call(this.upsertTableFilters(ack))
      .stream();