refactor(db): every entity in the snake_case shape; document-sync entities added; one repository per entity

server/src/db/entities/Addons.entity.ts

@@ -1,4 +1,5 @@
-import { type Opt, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, defineEntity, p } from '@mikro-orm/core';
+import { AddonsRepository } from '../repositories/Addons.repository';
 
 export interface AddonConfig {
   [key: string]: unknown;
@@ -9,25 +10,23 @@ export class Addons {
   name!: string;
   description?: string | null;
   type: string & Opt = 'global';
-  icon: string & Opt = 'Puzzle';
-  enabled: boolean & Opt | null = false;
-  config: AddonConfig & Opt | null = {};
-  sortOrder?: number | null = 0;
+  icon?: string | null = 'Puzzle';
+  enabled?: boolean | null = false;
+  config?: AddonConfig | null;
+  sort_order?: number | null = 0;
 }
 
-export class AddonsRepository extends EntityRepository<Addons>{}
-
 export const AddonsSchema = defineEntity({
   class: Addons,
   repository: () => AddonsRepository,
   properties: {
-    id: p.text().primary(),
+    id: p.text().primary().nullable(),
     name: p.text(),
     description: p.text().nullable(),
-    type: p.text(),
+    type: p.text().default('global'),
     icon: p.text().nullable(),
-    enabled: p.boolean().nullable().default(false),
-    config: p.json<AddonConfig>().nullable(),
-    sortOrder: p.integer().nullable(),
+    enabled: p.boolean().nullable(),
+    config: p.json<AddonConfig>().nullable().default('{}'),
+    sort_order: p.integer().nullable(),
   },
 });

server/src/db/entities/AppSettings.entity.ts

@@ -1,4 +1,5 @@
-import { PrimaryKeyProp, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { PrimaryKeyProp, defineEntity, p } from '@mikro-orm/core';
+import { AppSettingsRepository } from '../repositories/AppSettings.repository';
 
 export class AppSettings {
   [PrimaryKeyProp]?: 'key';
@@ -6,8 +7,6 @@ export class AppSettings {
   value?: string | null;
 }
 
-export class AppSettingsRepository extends EntityRepository<AppSettings> {}
-
 export const AppSettingsSchema = defineEntity({
   class: AppSettings,
   repository: () => AppSettingsRepository,

server/src/db/entities/AssignmentParticipants.entity.ts

@@ -1,21 +1,24 @@
-import { type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { AssignmentParticipantsRepository } from '../repositories/AssignmentParticipants.repository';
 import { DayAssignments } from './DayAssignments.entity';
 import { Users } from './Users.entity';
 
 export class AssignmentParticipants {
-  id?: number | null;
+  id!: number & Opt;
   assignment!: Ref<DayAssignments>;
+  assignment_id!: number;
   user!: Ref<Users>;
+  user_id!: number;
 }
 
-export class AssignmentParticipantsRepository extends EntityRepository<AssignmentParticipants> {}
-
 export const AssignmentParticipantsSchema = defineEntity({
   class: AssignmentParticipants,
   repository: () => AssignmentParticipantsRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    assignment: () => p.manyToOne(DayAssignments).ref().index('idx_assignment_participants_assignment'),
-    user: () => p.manyToOne(Users).ref(),
+    id: p.integer().primary(),
+    assignment: () => p.manyToOne(DayAssignments).ref().hidden().index('idx_assignment_participants_assignment'),
+    assignment_id: p.integer().persist(false).index('idx_assignment_participants_assignment'),
+    user: () => p.manyToOne(Users).ref().hidden(),
+    user_id: p.integer().persist(false),
   },
 });

server/src/db/entities/AuditLog.entity.ts

@@ -1,29 +1,27 @@
+import { type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { AuditLogRepository } from '../repositories/AuditLog.repository';
+import { DbTimestampType } from '../types';
 import { Users } from './Users.entity';
-import { defineEntity, p, type Ref, EntityRepository } from '@mikro-orm/core';
 
 export class AuditLog {
-  id?: number | null;
-  createdAt?: Date | null;
+  id!: number & Opt;
+  created_at?: string | null;
   user?: Ref<Users> | null;
+  user_id?: number | null;
   action!: string;
   resource?: string | null;
   details?: string | null;
   ip?: string | null;
 }
 
-export class AuditLogRepository extends EntityRepository<AuditLog> {}
-
 export const AuditLogSchema = defineEntity({
   class: AuditLog,
   repository: () => AuditLogRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    createdAt: p
-      .datetime()
-      .nullable()
-      .onCreate(() => new Date())
-      .index('idx_audit_log_created'),
-    user: () => p.manyToOne(Users).ref().nullable(),
+    id: p.integer().primary(),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`).index('idx_audit_log_created'),
+    user: () => p.manyToOne(Users).ref().nullable().hidden(),
+    user_id: p.integer().nullable().persist(false),
     action: p.text(),
     resource: p.text().nullable(),
     details: p.text().nullable(),

server/src/db/entities/BucketList.entity.ts

@@ -1,41 +1,43 @@
+import { Collection, type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { BucketListRepository } from '../repositories/BucketList.repository';
+import { DbTimestampType } from '../types';
 import { DawarichVisitSuggestions } from './DawarichVisitSuggestions.entity';
 import { Users } from './Users.entity';
-import { Collection, defineEntity, p, type Ref, EntityRepository } from '@mikro-orm/core';
 
 export class BucketList {
-  id?: number | null;
+  id!: number & Opt;
   user!: Ref<Users>;
+  user_id!: number;
   name!: string;
-  lat?: unknown | null;
-  lng?: unknown | null;
-  countryCode?: string | null;
+  lat?: number | null;
+  lng?: number | null;
+  country_code?: string | null;
   notes?: string | null;
-  createdAt?: Date | null;
-  targetDate?: string | null;
-  visitedAt?: string | null;
-  visitedSource?: string | null;
-  dawarichAcceptedBucketListItem = new Collection<DawarichVisitSuggestions>(this);
-  dawarichMatchedBucketListItem = new Collection<DawarichVisitSuggestions>(this);
+  created_at?: string | null;
+  target_date?: string | null;
+  visited_at?: string | null;
+  visited_source?: string | null;
+  dawarich_visit_suggestions_collection = new Collection<DawarichVisitSuggestions>(this);
+  dawarich_visit_suggestions_collection1 = new Collection<DawarichVisitSuggestions>(this);
 }
 
-export class BucketListRepository extends EntityRepository<BucketList> {}
-
 export const BucketListSchema = defineEntity({
   class: BucketList,
   repository: () => BucketListRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    user: () => p.manyToOne(Users).ref().deleteRule('cascade'),
+    id: p.integer().primary(),
+    user: () => p.manyToOne(Users).ref().deleteRule('cascade').hidden(),
+    user_id: p.integer().persist(false),
     name: p.text(),
     lat: p.double().nullable(),
     lng: p.double().nullable(),
-    countryCode: p.text().nullable(),
+    country_code: p.text().nullable(),
     notes: p.text().nullable(),
-    createdAt: p.datetime().nullable().onCreate(() => new Date()),
-    targetDate: p.text().nullable(),
-    visitedAt: p.text().nullable(),
-    visitedSource: p.text().nullable(),
-    dawarichAcceptedBucketListItem: () => p.oneToMany(DawarichVisitSuggestions).mappedBy('acceptedBucketListItem'),
-    dawarichMatchedBucketListItem: () => p.oneToMany(DawarichVisitSuggestions).mappedBy('matchedBucketListItem'),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
+    target_date: p.text().nullable().defaultRaw(`NULL`),
+    visited_at: p.text().nullable(),
+    visited_source: p.text().nullable(),
+    dawarich_visit_suggestions_collection: () => p.oneToMany(DawarichVisitSuggestions).mappedBy('acceptedBucketListItem').hidden(),
+    dawarich_visit_suggestions_collection1: () => p.oneToMany(DawarichVisitSuggestions).mappedBy('matchedBucketListItem').hidden(),
   },
 });

server/src/db/entities/BudgetCategoryOrder.entity.ts

@@ -14,7 +14,7 @@ export const BudgetCategoryOrderSchema = defineEntity({
   class: BudgetCategoryOrder,
   repository: () => BudgetCategoryOrderRepository,
   properties: {
-    trip: () => p.manyToOne(Trips).primary().ref().hidden().deleteRule('cascade'),
+    trip: () => p.manyToOne(Trips).primary().ref().deleteRule('cascade').hidden(),
     trip_id: p.integer().persist(false),
     category: p.text().primary(),
     sort_order: p.integer().default(0),

server/src/db/entities/BudgetItemMembers.entity.ts

@@ -1,25 +1,28 @@
-import { type Opt, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { BudgetItemMembersRepository } from '../repositories/BudgetItemMembers.repository';
 import { BudgetItems } from './BudgetItems.entity';
 import { Users } from './Users.entity';
 
 export class BudgetItemMembers {
-  id?: number | null;
+  id!: number & Opt;
   budgetItem!: Ref<BudgetItems>;
+  budget_item_id!: number;
   user!: Ref<Users>;
+  user_id!: number;
   paid: number & Opt = 0;
-  amount?: unknown | null;
+  amount?: number | null;
 }
 
-export class BudgetItemMembersRepository extends EntityRepository<BudgetItemMembers> {}
-
 export const BudgetItemMembersSchema = defineEntity({
   class: BudgetItemMembers,
   repository: () => BudgetItemMembersRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    budgetItem: () => p.manyToOne(BudgetItems).ref().deleteRule('cascade').index('idx_budget_item_members_item'),
-    user: () => p.manyToOne(Users).ref().deleteRule('cascade').index('idx_budget_item_members_user'),
-    paid: p.integer(),
+    id: p.integer().primary(),
+    budgetItem: () => p.manyToOne(BudgetItems).ref().deleteRule('cascade').hidden().index('idx_budget_item_members_item'),
+    budget_item_id: p.integer().persist(false).index('idx_budget_item_members_item'),
+    user: () => p.manyToOne(Users).ref().deleteRule('cascade').hidden().index('idx_budget_item_members_user'),
+    user_id: p.integer().persist(false).index('idx_budget_item_members_user'),
+    paid: p.integer().default(0),
     amount: p.double().nullable(),
   },
 });

server/src/db/entities/BudgetItemPayers.entity.ts

@@ -1,23 +1,26 @@
+import { type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { BudgetItemPayersRepository } from '../repositories/BudgetItemPayers.repository';
 import { BudgetItems } from './BudgetItems.entity';
 import { Users } from './Users.entity';
-import { type Ref, defineEntity, p, Opt, EntityRepository } from '@mikro-orm/core';
 
 export class BudgetItemPayers {
-  id?: number | null;
+  id!: number & Opt;
   budgetItem!: Ref<BudgetItems>;
+  budget_item_id!: number;
   user!: Ref<Users>;
-  amount: number & Opt = 0;
+  user_id!: number;
+  amount!: number & Opt;
 }
 
-export class BudgetItemPayersRepository extends EntityRepository<BudgetItemPayers> {}
-
 export const BudgetItemPayersSchema = defineEntity({
   class: BudgetItemPayers,
   repository: () => BudgetItemPayersRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    budgetItem: () => p.manyToOne(BudgetItems).ref().deleteRule('cascade').index('idx_budget_item_payers_item'),
-    user: () => p.manyToOne(Users).ref().deleteRule('cascade'),
-    amount: p.double().default(0),
+    id: p.integer().primary(),
+    budgetItem: () => p.manyToOne(BudgetItems).ref().deleteRule('cascade').hidden().index('idx_budget_item_payers_item'),
+    budget_item_id: p.integer().persist(false).index('idx_budget_item_payers_item'),
+    user: () => p.manyToOne(Users).ref().deleteRule('cascade').hidden(),
+    user_id: p.integer().persist(false),
+    amount: p.double().defaultRaw(`0`),
   },
 });

server/src/db/entities/BudgetItems.entity.ts

@@ -1,4 +1,6 @@
-import { Collection, type Opt, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { Collection, type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { BudgetItemsRepository } from '../repositories/BudgetItems.repository';
+import { DbTimestampType } from '../types';
 import { BudgetItemMembers } from './BudgetItemMembers.entity';
 import { BudgetItemPayers } from './BudgetItemPayers.entity';
 import { FileLinks } from './FileLinks.entity';
@@ -8,53 +10,59 @@ import { Trips } from './Trips.entity';
 import { Users } from './Users.entity';
 
 export class BudgetItems {
-  id?: number | null;
+  id!: number & Opt;
   trip!: Ref<Trips>;
+  trip_id!: number;
   category: string & Opt = 'Other';
   name!: string;
-  totalPrice!: number & Opt;
+  total_price!: number & Opt;
   persons?: number | null = NaN;
   days?: number | null = NaN;
   note?: string | null;
-  sortOrder?: number | null = 0;
-  createdAt?: Date | null;
+  sort_order?: number | null = 0;
+  created_at?: string | null;
   paidByUser?: Ref<Users> | null;
-  expenseDate?: string | null;
+  paid_by_user_id?: number | null;
+  expense_date?: string | null;
   reservation?: Ref<Reservations> | null;
+  reservation_id?: number | null = NaN;
   currency?: string | null;
-  exchangeRate!: number & Opt;
-  ticketJson?: string | null;
+  exchange_rate!: number & Opt;
+  ticket_json?: string | null;
   place?: Ref<Places> | null;
-  budgetItemMembersCollection = new Collection<BudgetItemMembers>(this);
-  budgetItemPayersCollection = new Collection<BudgetItemPayers>(this);
-  fileLinksCollection = new Collection<FileLinks>(this);
+  place_id?: number | null = NaN;
+  budget_item_members_collection = new Collection<BudgetItemMembers>(this);
+  budget_item_payers_collection = new Collection<BudgetItemPayers>(this);
+  file_links_collection = new Collection<FileLinks>(this);
 }
 
-export class BudgetItemsRepository extends EntityRepository<BudgetItems> {}
-
 export const BudgetItemsSchema = defineEntity({
   class: BudgetItems,
   repository: () => BudgetItemsRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    trip: () => p.manyToOne(Trips).ref().deleteRule('cascade').index('idx_budget_items_trip_id'),
-    category: p.text(),
+    id: p.integer().primary(),
+    trip: () => p.manyToOne(Trips).ref().deleteRule('cascade').hidden().index('idx_budget_items_trip_id'),
+    trip_id: p.integer().persist(false).index('idx_budget_items_trip_id'),
+    category: p.text().default('Other'),
     name: p.text(),
-    totalPrice: p.double().default(0),
-    persons: p.integer().nullable(),
-    days: p.integer().nullable(),
+    total_price: p.double().defaultRaw(`0`),
+    persons: p.integer().nullable().defaultRaw(`NULL`),
+    days: p.integer().nullable().defaultRaw(`NULL`),
     note: p.text().nullable(),
-    sortOrder: p.integer().nullable(),
-    createdAt: p.datetime().nullable().onCreate(() => new Date()),
-    paidByUser: () => p.manyToOne(Users).ref().nullable(),
-    expenseDate: p.text().nullable(),
-    reservation: () => p.manyToOne(Reservations).ref().nullable(),
+    sort_order: p.integer().nullable(),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
+    paidByUser: () => p.manyToOne(Users).ref().nullable().hidden(),
+    paid_by_user_id: p.integer().nullable().persist(false),
+    expense_date: p.text().nullable().defaultRaw(`NULL`),
+    reservation: () => p.manyToOne(Reservations).ref().nullable().hidden().defaultRaw(`NULL`),
+    reservation_id: p.integer().nullable().persist(false).defaultRaw(`NULL`),
     currency: p.text().nullable(),
-    exchangeRate: p.double().default(1),
-    ticketJson: p.text().nullable(),
-    place: () => p.manyToOne(Places).ref().nullable(),
-    budgetItemMembersCollection: () => p.oneToMany(BudgetItemMembers).mappedBy('budgetItem'),
-    budgetItemPayersCollection: () => p.oneToMany(BudgetItemPayers).mappedBy('budgetItem'),
-    fileLinksCollection: () => p.oneToMany(FileLinks).mappedBy('budgetItem'),
+    exchange_rate: p.double().defaultRaw(`1`),
+    ticket_json: p.text().nullable(),
+    place: () => p.manyToOne(Places).ref().nullable().hidden().defaultRaw(`NULL`),
+    place_id: p.integer().nullable().persist(false).defaultRaw(`NULL`),
+    budget_item_members_collection: () => p.oneToMany(BudgetItemMembers).mappedBy('budgetItem').hidden(),
+    budget_item_payers_collection: () => p.oneToMany(BudgetItemPayers).mappedBy('budgetItem').hidden(),
+    file_links_collection: () => p.oneToMany(FileLinks).mappedBy('budgetItem').hidden(),
   },
 });

server/src/db/entities/BudgetSettlements.entity.ts

@@ -1,35 +1,43 @@
-import { type Opt, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { BudgetSettlementsRepository } from '../repositories/BudgetSettlements.repository';
+import { DbTimestampType } from '../types';
 import { Trips } from './Trips.entity';
 import { Users } from './Users.entity';
 
 export class BudgetSettlements {
-  id?: number | null;
+  id!: number & Opt;
   trip!: Ref<Trips>;
+  trip_id!: number;
   fromUser!: Ref<Users>;
+  from_user_id!: number;
   toUser!: Ref<Users>;
-  amount!: number;
-  createdAt?: Date | null;
+  to_user_id!: number;
+  amount!: number & Opt;
+  created_at?: string | null;
   createdByUser?: Ref<Users> | null;
+  created_by_user_id?: number | null;
   currency?: string | null;
-  exchangeRate!: number;
-  settledAt?: string | null;
+  exchange_rate!: number & Opt;
+  settled_at?: string | null;
 }
 
-export class BudgetSettlementsRepository extends EntityRepository<BudgetSettlements> {}
-
 export const BudgetSettlementsSchema = defineEntity({
   class: BudgetSettlements,
   repository: () => BudgetSettlementsRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    trip: () => p.manyToOne(Trips).ref().deleteRule('cascade').index('idx_budget_settlements_trip'),
-    fromUser: () => p.manyToOne(Users).ref().deleteRule('cascade'),
-    toUser: () => p.manyToOne(Users).ref().deleteRule('cascade'),
-    amount: p.double().default(0),
-    createdAt: p.datetime().nullable().onCreate(() => new Date()),
-    createdByUser: () => p.manyToOne(Users).ref().nullable(),
+    id: p.integer().primary(),
+    trip: () => p.manyToOne(Trips).ref().deleteRule('cascade').hidden().index('idx_budget_settlements_trip'),
+    trip_id: p.integer().persist(false).index('idx_budget_settlements_trip'),
+    fromUser: () => p.manyToOne(Users).ref().deleteRule('cascade').hidden(),
+    from_user_id: p.integer().persist(false),
+    toUser: () => p.manyToOne(Users).ref().deleteRule('cascade').hidden(),
+    to_user_id: p.integer().persist(false),
+    amount: p.double().defaultRaw(`0`),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
+    createdByUser: () => p.manyToOne(Users).ref().nullable().hidden(),
+    created_by_user_id: p.integer().nullable().persist(false),
     currency: p.text().nullable(),
-    exchangeRate: p.double().default(1),
-    settledAt: p.text().nullable(),
+    exchange_rate: p.double().defaultRaw(`1`),
+    settled_at: p.text().nullable(),
   },
 });

server/src/db/entities/Categories.entity.ts

@@ -1,32 +1,34 @@
-import { Collection, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { Collection, type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { CategoriesRepository } from '../repositories/Categories.repository';
+import { DbTimestampType } from '../types';
 import { CollectionPlaces } from './CollectionPlaces.entity';
 import { Places } from './Places.entity';
 import { Users } from './Users.entity';
 
 export class Categories {
-  id?: number | null;
+  id!: number & Opt;
   name!: string;
   color?: string | null = '#6366f1';
   icon?: string | null = '📍';
   user?: Ref<Users> | null;
-  createdAt?: Date | null;
-  collectionPlacesCollection = new Collection<CollectionPlaces>(this);
-  placesCollection = new Collection<Places>(this);
+  user_id?: number | null;
+  created_at?: string | null;
+  collection_places_collection = new Collection<CollectionPlaces>(this);
+  places_collection = new Collection<Places>(this);
 }
 
-export class CategoriesRepository extends EntityRepository<Categories> {}
-
 export const CategoriesSchema = defineEntity({
   class: Categories,
   repository: () => CategoriesRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
+    id: p.integer().primary(),
     name: p.text(),
     color: p.text().nullable(),
     icon: p.text().nullable(),
-    user: () => p.manyToOne(Users).ref().nullable(),
-    createdAt: p.datetime().nullable().onCreate(() => new Date()),
-    collectionPlacesCollection: () => p.oneToMany(CollectionPlaces).mappedBy('category'),
-    placesCollection: () => p.oneToMany(Places).mappedBy('category'),
+    user: () => p.manyToOne(Users).ref().nullable().hidden(),
+    user_id: p.integer().nullable().persist(false),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
+    collection_places_collection: () => p.oneToMany(CollectionPlaces).mappedBy('category').hidden(),
+    places_collection: () => p.oneToMany(Places).mappedBy('category').hidden(),
   },
 });

server/src/db/entities/CollabLinks.entity.ts

@@ -1,31 +1,35 @@
-import { type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { CollabLinksRepository } from '../repositories/CollabLinks.repository';
+import { DbTimestampType } from '../types';
 import { Trips } from './Trips.entity';
 import { Users } from './Users.entity';
 
 export class CollabLinks {
-  id?: number | null;
+  id!: number & Opt;
   trip!: Ref<Trips>;
+  trip_id!: number;
   user!: Ref<Users>;
+  user_id!: number;
   title!: string;
   url!: string;
   pinned?: number | null = 0;
-  createdAt?: Date | null;
-  updatedAt?: Date | null;
+  created_at?: string | null;
+  updated_at?: string | null;
 }
 
-export class CollabLinksRepository extends EntityRepository<CollabLinks> {}
-
 export const CollabLinksSchema = defineEntity({
   class: CollabLinks,
   repository: () => CollabLinksRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    trip: () => p.manyToOne(Trips).ref().deleteRule('cascade').index('idx_collab_links_trip'),
-    user: () => p.manyToOne(Users).ref().deleteRule('cascade'),
+    id: p.integer().primary(),
+    trip: () => p.manyToOne(Trips).ref().deleteRule('cascade').hidden().index('idx_collab_links_trip'),
+    trip_id: p.integer().persist(false).index('idx_collab_links_trip'),
+    user: () => p.manyToOne(Users).ref().deleteRule('cascade').hidden(),
+    user_id: p.integer().persist(false),
     title: p.text(),
     url: p.text(),
     pinned: p.integer().nullable(),
-    createdAt: p.datetime().nullable().onCreate(() => new Date()),
-    updatedAt: p.datetime().nullable().onCreate(() => new Date()),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
+    updated_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
   },
 });

server/src/db/entities/CollabMessageReactions.entity.ts

@@ -1,25 +1,29 @@
-import { type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { CollabMessageReactionsRepository } from '../repositories/CollabMessageReactions.repository';
+import { DbTimestampType } from '../types';
 import { CollabMessages } from './CollabMessages.entity';
 import { Users } from './Users.entity';
 
 export class CollabMessageReactions {
-  id?: number | null;
+  id!: number & Opt;
   message!: Ref<CollabMessages>;
+  message_id!: number;
   user!: Ref<Users>;
+  user_id!: number;
   emoji!: string;
-  createdAt?: Date | null;
+  created_at?: string | null;
 }
 
-export class CollabMessageReactionsRepository extends EntityRepository<CollabMessageReactions> {}
-
 export const CollabMessageReactionsSchema = defineEntity({
   class: CollabMessageReactions,
   repository: () => CollabMessageReactionsRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    message: () => p.manyToOne(CollabMessages).ref().deleteRule('cascade').index('idx_collab_reactions_msg'),
-    user: () => p.manyToOne(Users).ref().deleteRule('cascade'),
+    id: p.integer().primary(),
+    message: () => p.manyToOne(CollabMessages).ref().deleteRule('cascade').hidden().index('idx_collab_reactions_msg'),
+    message_id: p.integer().persist(false).index('idx_collab_reactions_msg'),
+    user: () => p.manyToOne(Users).ref().deleteRule('cascade').hidden(),
+    user_id: p.integer().persist(false),
     emoji: p.text(),
-    createdAt: p.datetime().nullable().onCreate(() => new Date()),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
   },
 });

server/src/db/entities/CollabMessages.entity.ts

@@ -1,37 +1,43 @@
-import { Collection, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { Collection, type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { CollabMessagesRepository } from '../repositories/CollabMessages.repository';
+import { DbTimestampType } from '../types';
 import { CollabMessageReactions } from './CollabMessageReactions.entity';
 import { TripFiles } from './TripFiles.entity';
 import { Trips } from './Trips.entity';
 import { Users } from './Users.entity';
 
 export class CollabMessages {
-  id?: number | null;
+  id!: number & Opt;
   trip!: Ref<Trips>;
+  trip_id!: number;
   user!: Ref<Users>;
+  user_id!: number;
   text!: string;
-  replyTo?: Ref<CollabMessages> | null;
-  createdAt?: Date | null;
+  reply_to?: number | null;
+  created_at?: string | null;
   deleted?: number | null = 0;
-  collabMessageReactionsCollection = new Collection<CollabMessageReactions>(this);
-  collabMessagesCollection = new Collection<CollabMessages>(this);
-  tripFilesCollection = new Collection<TripFiles>(this);
+  replyToRef?: Ref<CollabMessages> | null;
+  collab_message_reactions_collection = new Collection<CollabMessageReactions>(this);
+  collab_messages_collection = new Collection<CollabMessages>(this);
+  trip_files_collection = new Collection<TripFiles>(this);
 }
 
-export class CollabMessagesRepository extends EntityRepository<CollabMessages> {}
-
 export const CollabMessagesSchema = defineEntity({
   class: CollabMessages,
   repository: () => CollabMessagesRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    trip: () => p.manyToOne(Trips).ref().deleteRule('cascade').index('idx_collab_messages_trip'),
-    user: () => p.manyToOne(Users).ref().deleteRule('cascade'),
+    id: p.integer().primary(),
+    trip: () => p.manyToOne(Trips).ref().deleteRule('cascade').hidden().index('idx_collab_messages_trip'),
+    trip_id: p.integer().persist(false).index('idx_collab_messages_trip'),
+    user: () => p.manyToOne(Users).ref().deleteRule('cascade').hidden(),
+    user_id: p.integer().persist(false),
     text: p.text(),
-    replyTo: () => p.manyToOne(CollabMessages).ref().name('reply_to').nullable(),
-    createdAt: p.datetime().nullable().onCreate(() => new Date()),
+    reply_to: p.integer().nullable().persist(false),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
     deleted: p.integer().nullable(),
-    collabMessageReactionsCollection: () => p.oneToMany(CollabMessageReactions).mappedBy('message'),
-    collabMessagesCollection: () => p.oneToMany(CollabMessages).mappedBy('replyTo'),
-    tripFilesCollection: () => p.oneToMany(TripFiles).mappedBy('message'),
+    replyToRef: () => p.manyToOne(CollabMessages).ref().joinColumn('reply_to').nullable().hidden(),
+    collab_message_reactions_collection: () => p.oneToMany(CollabMessageReactions).mappedBy('message').hidden(),
+    collab_messages_collection: () => p.oneToMany(CollabMessages).mappedBy('replyToRef').hidden(),
+    trip_files_collection: () => p.oneToMany(TripFiles).mappedBy('message').hidden(),
   },
 });

server/src/db/entities/CollabNotes.entity.ts

@@ -1,40 +1,44 @@
-import { Collection, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { Collection, type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { CollabNotesRepository } from '../repositories/CollabNotes.repository';
+import { DbTimestampType } from '../types';
 import { TripFiles } from './TripFiles.entity';
 import { Trips } from './Trips.entity';
 import { Users } from './Users.entity';
 
 export class CollabNotes {
-  id?: number | null;
+  id!: number & Opt;
   trip!: Ref<Trips>;
+  trip_id!: number;
   user!: Ref<Users>;
+  user_id!: number;
   category?: string | null = 'General';
   title!: string;
   content?: string | null;
   color?: string | null = '#6366f1';
   pinned?: number | null = 0;
-  createdAt?: Date | null;
-  updatedAt?: Date | null;
+  created_at?: string | null;
+  updated_at?: string | null;
   website?: string | null;
-  tripFilesCollection = new Collection<TripFiles>(this);
+  trip_files_collection = new Collection<TripFiles>(this);
 }
 
-export class CollabNotesRepository extends EntityRepository<CollabNotes> {}
-
 export const CollabNotesSchema = defineEntity({
   class: CollabNotes,
   repository: () => CollabNotesRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    trip: () => p.manyToOne(Trips).ref().deleteRule('cascade').index('idx_collab_notes_trip'),
-    user: () => p.manyToOne(Users).ref().deleteRule('cascade'),
+    id: p.integer().primary(),
+    trip: () => p.manyToOne(Trips).ref().deleteRule('cascade').hidden().index('idx_collab_notes_trip'),
+    trip_id: p.integer().persist(false).index('idx_collab_notes_trip'),
+    user: () => p.manyToOne(Users).ref().deleteRule('cascade').hidden(),
+    user_id: p.integer().persist(false),
     category: p.text().nullable(),
     title: p.text(),
     content: p.text().nullable(),
     color: p.text().nullable(),
     pinned: p.integer().nullable(),
-    createdAt: p.datetime().nullable().onCreate(() => new Date()),
-    updatedAt: p.datetime().nullable().onCreate(() => new Date()),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
+    updated_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
     website: p.text().nullable(),
-    tripFilesCollection: () => p.oneToMany(TripFiles).mappedBy('note'),
+    trip_files_collection: () => p.oneToMany(TripFiles).mappedBy('note').hidden(),
   },
 });

server/src/db/entities/CollabPollVotes.entity.ts

@@ -1,25 +1,29 @@
-import { type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { CollabPollVotesRepository } from '../repositories/CollabPollVotes.repository';
+import { DbTimestampType } from '../types';
 import { CollabPolls } from './CollabPolls.entity';
 import { Users } from './Users.entity';
 
 export class CollabPollVotes {
-  id?: number | null;
+  id!: number & Opt;
   poll!: Ref<CollabPolls>;
+  poll_id!: number;
   user!: Ref<Users>;
-  optionIndex!: number;
-  createdAt?: Date | null;
+  user_id!: number;
+  option_index!: number;
+  created_at?: string | null;
 }
 
-export class CollabPollVotesRepository extends EntityRepository<CollabPollVotes> {}
-
 export const CollabPollVotesSchema = defineEntity({
   class: CollabPollVotes,
   repository: () => CollabPollVotesRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    poll: () => p.manyToOne(CollabPolls).ref().deleteRule('cascade'),
-    user: () => p.manyToOne(Users).ref().deleteRule('cascade'),
-    optionIndex: p.integer(),
-    createdAt: p.datetime().nullable().onCreate(() => new Date()),
+    id: p.integer().primary(),
+    poll: () => p.manyToOne(CollabPolls).ref().deleteRule('cascade').hidden(),
+    poll_id: p.integer().persist(false),
+    user: () => p.manyToOne(Users).ref().deleteRule('cascade').hidden(),
+    user_id: p.integer().persist(false),
+    option_index: p.integer(),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
   },
 });

server/src/db/entities/CollabPolls.entity.ts

@@ -1,36 +1,40 @@
-import { Collection, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { Collection, type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { CollabPollsRepository } from '../repositories/CollabPolls.repository';
+import { DbTimestampType } from '../types';
 import { CollabPollVotes } from './CollabPollVotes.entity';
 import { Trips } from './Trips.entity';
 import { Users } from './Users.entity';
 
 export class CollabPolls {
-  id?: number | null;
+  id!: number & Opt;
   trip!: Ref<Trips>;
+  trip_id!: number;
   user!: Ref<Users>;
+  user_id!: number;
   question!: string;
   options!: string;
   multiple?: number | null = 0;
   closed?: number | null = 0;
   deadline?: string | null;
-  createdAt?: Date | null;
-  collabPollVotesCollection = new Collection<CollabPollVotes>(this);
+  created_at?: string | null;
+  collab_poll_votes_collection = new Collection<CollabPollVotes>(this);
 }
 
-export class CollabPollsRepository extends EntityRepository<CollabPolls> {}
-
 export const CollabPollsSchema = defineEntity({
   class: CollabPolls,
   repository: () => CollabPollsRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    trip: () => p.manyToOne(Trips).ref().deleteRule('cascade').index('idx_collab_polls_trip'),
-    user: () => p.manyToOne(Users).ref().deleteRule('cascade'),
+    id: p.integer().primary(),
+    trip: () => p.manyToOne(Trips).ref().deleteRule('cascade').hidden().index('idx_collab_polls_trip'),
+    trip_id: p.integer().persist(false).index('idx_collab_polls_trip'),
+    user: () => p.manyToOne(Users).ref().deleteRule('cascade').hidden(),
+    user_id: p.integer().persist(false),
     question: p.text(),
     options: p.text(),
     multiple: p.integer().nullable(),
     closed: p.integer().nullable(),
     deadline: p.text().nullable(),
-    createdAt: p.datetime().nullable().onCreate(() => new Date()),
-    collabPollVotesCollection: () => p.oneToMany(CollabPollVotes).mappedBy('poll'),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
+    collab_poll_votes_collection: () => p.oneToMany(CollabPollVotes).mappedBy('poll').hidden(),
   },
 });

server/src/db/entities/CollectionLabels.entity.ts

@@ -1,29 +1,31 @@
-import { Collection, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { Collection, type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { CollectionLabelsRepository } from '../repositories/CollectionLabels.repository';
+import { DbTimestampType } from '../types';
 import { CollectionPlaces } from './CollectionPlaces.entity';
 import { Collections } from './Collections.entity';
 
 export class CollectionLabels {
-  id?: number | null;
+  id!: number & Opt;
   collection!: Ref<Collections>;
+  collection_id!: number;
   name!: string;
   color?: string | null = '#6366f1';
-  sortOrder?: number | null = 0;
-  createdAt?: Date | null;
-  collectionPlaceLabelsInverse = new Collection<CollectionPlaces>(this);
+  sort_order?: number | null = 0;
+  created_at?: string | null;
+  collection_place_labels_inverse = new Collection<CollectionPlaces>(this);
 }
 
-export class CollectionLabelsRepository extends EntityRepository<CollectionLabels> {}
-
 export const CollectionLabelsSchema = defineEntity({
   class: CollectionLabels,
   repository: () => CollectionLabelsRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    collection: () => p.manyToOne(Collections).ref().deleteRule('cascade').index('idx_collection_labels_collection'),
+    id: p.integer().primary(),
+    collection: () => p.manyToOne(Collections).ref().deleteRule('cascade').hidden().index('idx_collection_labels_collection'),
+    collection_id: p.integer().persist(false).index('idx_collection_labels_collection'),
     name: p.text(),
     color: p.text().nullable(),
-    sortOrder: p.integer().nullable(),
-    createdAt: p.datetime().nullable().onCreate(() => new Date()),
-    collectionPlaceLabelsInverse: () => p.manyToMany(CollectionPlaces).mappedBy('collectionPlaceLabels'),
+    sort_order: p.integer().nullable(),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
+    collection_place_labels_inverse: () => p.manyToMany(CollectionPlaces).mappedBy('collection_place_labels').hidden(),
   },
 });

server/src/db/entities/CollectionMembers.entity.ts

@@ -1,27 +1,31 @@
-import { type Opt, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { CollectionMembersRepository } from '../repositories/CollectionMembers.repository';
+import { DbTimestampType } from '../types';
 import { Collections } from './Collections.entity';
 import { Users } from './Users.entity';
 
 export class CollectionMembers {
-  id?: number | null;
+  id!: number & Opt;
   collection!: Ref<Collections>;
+  collection_id!: number;
   user!: Ref<Users>;
+  user_id!: number;
   status: string & Opt = 'pending';
   role: string & Opt = 'editor';
-  createdAt?: Date | null;
+  created_at?: string | null;
 }
 
-export class CollectionMembersRepository extends EntityRepository<CollectionMembers> {}
-
 export const CollectionMembersSchema = defineEntity({
   class: CollectionMembers,
   repository: () => CollectionMembersRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    collection: () => p.manyToOne(Collections).ref().deleteRule('cascade'),
-    user: () => p.manyToOne(Users).ref().deleteRule('cascade').index('idx_collection_members_user'),
-    status: p.text(),
-    role: p.text(),
-    createdAt: p.datetime().nullable().onCreate(() => new Date()),
+    id: p.integer().primary(),
+    collection: () => p.manyToOne(Collections).ref().deleteRule('cascade').hidden(),
+    collection_id: p.integer().persist(false),
+    user: () => p.manyToOne(Users).ref().deleteRule('cascade').hidden().index('idx_collection_members_user'),
+    user_id: p.integer().persist(false).index('idx_collection_members_user'),
+    status: p.text().default('pending'),
+    role: p.text().default('editor'),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
   },
 });

server/src/db/entities/CollectionPlaceRatings.entity.ts

@@ -1,25 +1,29 @@
-import { type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { CollectionPlaceRatingsRepository } from '../repositories/CollectionPlaceRatings.repository';
+import { DbTimestampType } from '../types';
 import { CollectionPlaces } from './CollectionPlaces.entity';
 import { Users } from './Users.entity';
 
 export class CollectionPlaceRatings {
-  id?: number | null;
+  id!: number & Opt;
   collectionPlace!: Ref<CollectionPlaces>;
+  collection_place_id!: number;
   user!: Ref<Users>;
+  user_id!: number;
   rating!: number;
-  createdAt?: Date | null;
+  created_at?: string | null;
 }
 
-export class CollectionPlaceRatingsRepository extends EntityRepository<CollectionPlaceRatings> {}
-
 export const CollectionPlaceRatingsSchema = defineEntity({
   class: CollectionPlaceRatings,
   repository: () => CollectionPlaceRatingsRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    collectionPlace: () => p.manyToOne(CollectionPlaces).ref().deleteRule('cascade').index('idx_collection_place_ratings_place'),
-    user: () => p.manyToOne(Users).ref().deleteRule('cascade'),
+    id: p.integer().primary(),
+    collectionPlace: () => p.manyToOne(CollectionPlaces).ref().deleteRule('cascade').hidden().index('idx_collection_place_ratings_place'),
+    collection_place_id: p.integer().persist(false).index('idx_collection_place_ratings_place'),
+    user: () => p.manyToOne(Users).ref().deleteRule('cascade').hidden(),
+    user_id: p.integer().persist(false),
     rating: p.integer(),
-    createdAt: p.datetime().nullable().onCreate(() => new Date()),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
   },
 });

server/src/db/entities/CollectionPlaces.entity.ts

@@ -1,4 +1,6 @@
-import { Collection, type Opt, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { Collection, type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { CollectionPlacesRepository } from '../repositories/CollectionPlaces.repository';
+import { DbTimestampType } from '../types';
 import { Categories } from './Categories.entity';
 import { CollectionLabels } from './CollectionLabels.entity';
 import { CollectionPlaceRatings } from './CollectionPlaceRatings.entity';
@@ -7,71 +9,77 @@ import { Tags } from './Tags.entity';
 import { Users } from './Users.entity';
 
 export class CollectionPlaces {
-  id?: number | null;
+  id!: number & Opt;
   collection!: Ref<Collections>;
+  collection_id!: number;
   owner!: Ref<Users>;
-  savedBy?: Ref<Users> | null;
+  owner_id!: number;
+  saved_by?: number | null;
   name!: string;
   description?: string | null;
-  lat?: unknown | null;
-  lng?: unknown | null;
+  lat?: number | null;
+  lng?: number | null;
   address?: string | null;
   category?: Ref<Categories> | null;
-  price?: unknown | null;
+  category_id?: number | null;
+  price?: number | null;
   currency?: string | null;
   notes?: string | null;
-  imageUrl?: string | null;
-  googlePlaceId?: string | null;
-  googleFtid?: string | null;
-  osmId?: string | null;
+  image_url?: string | null;
+  google_place_id?: string | null;
+  google_ftid?: string | null;
+  osm_id?: string | null;
   website?: string | null;
   phone?: string | null;
   status: string & Opt = 'idea';
-  sourceTripId?: number | null;
-  sourcePlaceId?: number | null;
+  source_trip_id?: number | null;
+  source_place_id?: number | null;
   links?: string | null;
-  sortOrder?: number | null = 0;
-  createdAt?: Date | null;
-  updatedAt?: Date | null;
-  collectionPlaceLabels = new Collection<CollectionLabels>(this);
-  collectionPlaceTags = new Collection<Tags>(this);
-  collectionPlaceRatingsCollection = new Collection<CollectionPlaceRatings>(this);
+  sort_order?: number | null = 0;
+  created_at?: string | null;
+  updated_at?: string | null;
+  savedByRef?: Ref<Users> | null;
+  collection_place_labels = new Collection<CollectionLabels>(this);
+  collection_place_tags = new Collection<Tags>(this);
+  collection_place_ratings_collection = new Collection<CollectionPlaceRatings>(this);
 }
 
-export class CollectionPlacesRepository extends EntityRepository<CollectionPlaces> {}
-
 export const CollectionPlacesSchema = defineEntity({
   class: CollectionPlaces,
   repository: () => CollectionPlacesRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    collection: () => p.manyToOne(Collections).ref().deleteRule('cascade').index('idx_collection_places_collection'),
-    owner: () => p.manyToOne(Users).ref().deleteRule('cascade'),
-    savedBy: () => p.manyToOne(Users).ref().name('saved_by').nullable(),
+    id: p.integer().primary(),
+    collection: () => p.manyToOne(Collections).ref().deleteRule('cascade').hidden().index('idx_collection_places_collection'),
+    collection_id: p.integer().persist(false).index('idx_collection_places_collection'),
+    owner: () => p.manyToOne(Users).ref().deleteRule('cascade').hidden(),
+    owner_id: p.integer().persist(false),
+    saved_by: p.integer().nullable().persist(false),
     name: p.text(),
     description: p.text().nullable(),
     lat: p.double().nullable(),
     lng: p.double().nullable(),
     address: p.text().nullable(),
-    category: () => p.manyToOne(Categories).ref().nullable(),
+    category: () => p.manyToOne(Categories).ref().nullable().hidden(),
+    category_id: p.integer().nullable().persist(false),
     price: p.double().nullable(),
     currency: p.text().nullable(),
     notes: p.text().nullable(),
-    imageUrl: p.text().nullable(),
-    googlePlaceId: p.text().nullable(),
-    googleFtid: p.text().nullable(),
-    osmId: p.text().nullable(),
+    image_url: p.text().nullable(),
+    google_place_id: p.text().nullable(),
+    google_ftid: p.text().nullable(),
+    osm_id: p.text().nullable(),
     website: p.text().nullable(),
     phone: p.text().nullable(),
-    status: p.text(),
-    sourceTripId: p.integer().nullable(),
-    sourcePlaceId: p.integer().nullable(),
+    status: p.text().default('idea'),
+    source_trip_id: p.integer().nullable(),
+    source_place_id: p.integer().nullable(),
     links: p.text().nullable(),
-    sortOrder: p.integer().nullable(),
-    createdAt: p.datetime().nullable().onCreate(() => new Date()),
-    updatedAt: p.datetime().nullable().onCreate(() => new Date()),
-    collectionPlaceLabels: () => p.manyToMany(CollectionLabels).pivotTable('collection_place_labels').joinColumn('collection_place_id').inverseJoinColumn('label_id'),
-    collectionPlaceTags: () => p.manyToMany(Tags).pivotTable('collection_place_tags').joinColumn('collection_place_id').inverseJoinColumn('tag_id'),
-    collectionPlaceRatingsCollection: () => p.oneToMany(CollectionPlaceRatings).mappedBy('collectionPlace'),
+    sort_order: p.integer().nullable(),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
+    updated_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
+    savedByRef: () => p.manyToOne(Users).ref().joinColumn('saved_by').nullable().hidden(),
+    collection_place_labels: () => p.manyToMany(CollectionLabels).pivotTable('collection_place_labels').joinColumn('collection_place_id').inverseJoinColumn('label_id').hidden(),
+    collection_place_tags: () => p.manyToMany(Tags).pivotTable('collection_place_tags').joinColumn('collection_place_id').inverseJoinColumn('tag_id').hidden(),
+    collection_place_ratings_collection: () => p.oneToMany(CollectionPlaceRatings).mappedBy('collectionPlace').hidden(),
   },
 });

server/src/db/entities/Collections.entity.ts

@@ -1,45 +1,47 @@
-import { Collection, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { Collection, type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { CollectionsRepository } from '../repositories/Collections.repository';
+import { DbTimestampType } from '../types';
 import { CollectionLabels } from './CollectionLabels.entity';
 import { CollectionMembers } from './CollectionMembers.entity';
 import { CollectionPlaces } from './CollectionPlaces.entity';
 import { Users } from './Users.entity';
 
 export class Collections {
-  id?: number | null;
+  id!: number & Opt;
   owner!: Ref<Users>;
+  owner_id!: number;
   name!: string;
   description?: string | null;
   color?: string | null = '#6366f1';
   icon?: string | null = 'Bookmark';
-  coverImage?: string | null;
+  cover_image?: string | null;
   links?: string | null;
-  sortOrder?: number | null = 0;
-  createdAt?: Date | null;
-  updatedAt?: Date | null;
-  collectionLabelsCollection = new Collection<CollectionLabels>(this);
-  collectionMembersCollection = new Collection<CollectionMembers>(this);
-  collectionPlacesCollection = new Collection<CollectionPlaces>(this);
+  sort_order?: number | null = 0;
+  created_at?: string | null;
+  updated_at?: string | null;
+  collection_labels_collection = new Collection<CollectionLabels>(this);
+  collection_members_collection = new Collection<CollectionMembers>(this);
+  collection_places_collection = new Collection<CollectionPlaces>(this);
 }
 
-export class CollectionsRepository extends EntityRepository<Collections> {}
-
 export const CollectionsSchema = defineEntity({
   class: Collections,
   repository: () => CollectionsRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    owner: () => p.manyToOne(Users).ref().deleteRule('cascade'),
+    id: p.integer().primary(),
+    owner: () => p.manyToOne(Users).ref().deleteRule('cascade').hidden(),
+    owner_id: p.integer().persist(false),
     name: p.text(),
     description: p.text().nullable(),
     color: p.text().nullable(),
     icon: p.text().nullable(),
-    coverImage: p.text().nullable(),
+    cover_image: p.text().nullable(),
     links: p.text().nullable(),
-    sortOrder: p.integer().nullable(),
-    createdAt: p.datetime().nullable().onCreate(() => new Date()),
-    updatedAt: p.datetime().nullable().onCreate(() => new Date()),
-    collectionLabelsCollection: () => p.oneToMany(CollectionLabels).mappedBy('collection'),
-    collectionMembersCollection: () => p.oneToMany(CollectionMembers).mappedBy('collection'),
-    collectionPlacesCollection: () => p.oneToMany(CollectionPlaces).mappedBy('collection'),
+    sort_order: p.integer().nullable(),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
+    updated_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
+    collection_labels_collection: () => p.oneToMany(CollectionLabels).mappedBy('collection').hidden(),
+    collection_members_collection: () => p.oneToMany(CollectionMembers).mappedBy('collection').hidden(),
+    collection_places_collection: () => p.oneToMany(CollectionPlaces).mappedBy('collection').hidden(),
   },
 });

server/src/db/entities/DawarichConnections.entity.ts

@@ -1,37 +1,39 @@
-import { type Opt, PrimaryKeyProp, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, PrimaryKeyProp, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { DawarichConnectionsRepository } from '../repositories/DawarichConnections.repository';
+import { DbTimestampType } from '../types';
 import { Users } from './Users.entity';
 
 export class DawarichConnections {
   [PrimaryKeyProp]?: 'user';
   user?: Ref<Users> | null;
+  user_id?: number | null;
   url?: string | null;
-  apiKey?: string | null;
-  allowInsecureTls: number & Opt = 0;
-  syncEnabled: number & Opt = 1;
-  lastSyncAt?: string | null;
-  lastSyncState: string & Opt = 'never';
-  lastSyncError?: string | null;
+  api_key?: string | null;
+  allow_insecure_tls: number & Opt = 0;
+  sync_enabled: number & Opt = 1;
+  last_sync_at?: string | null;
+  last_sync_state: string & Opt = 'never';
+  last_sync_error?: string | null;
   capabilities?: string | null;
-  createdAt?: Date | null;
-  updatedAt?: Date | null;
+  created_at?: string | null;
+  updated_at?: string | null;
 }
 
-export class DawarichConnectionsRepository extends EntityRepository<DawarichConnections> {}
-
 export const DawarichConnectionsSchema = defineEntity({
   class: DawarichConnections,
   repository: () => DawarichConnectionsRepository,
   properties: {
-    user: () => p.oneToOne(Users).primary().ref().nullable(),
+    user: () => p.oneToOne(Users).primary().ref().nullable().hidden(),
+    user_id: p.integer().nullable().persist(false),
     url: p.text().nullable(),
-    apiKey: p.text().nullable(),
-    allowInsecureTls: p.integer(),
-    syncEnabled: p.integer(),
-    lastSyncAt: p.text().nullable(),
-    lastSyncState: p.text(),
-    lastSyncError: p.text().nullable(),
+    api_key: p.text().nullable(),
+    allow_insecure_tls: p.integer().default(0),
+    sync_enabled: p.integer().default(1),
+    last_sync_at: p.text().nullable(),
+    last_sync_state: p.text().default('never'),
+    last_sync_error: p.text().nullable(),
     capabilities: p.text().nullable(),
-    createdAt: p.datetime().nullable().onCreate(() => new Date()),
-    updatedAt: p.datetime().nullable().onCreate(() => new Date()),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
+    updated_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
   },
 });

server/src/db/entities/DawarichVisitSuggestions.entity.ts

@@ -1,70 +1,84 @@
+import { type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { DawarichVisitSuggestionsRepository } from '../repositories/DawarichVisitSuggestions.repository';
 import { BucketList } from './BucketList.entity';
 import { Places } from './Places.entity';
 import { Trips } from './Trips.entity';
 import { Users } from './Users.entity';
-import { defineEntity, EntityRepository, type Opt, p, type Ref } from '@mikro-orm/core';
 
 export class DawarichVisitSuggestions {
-  id?: number | null;
+  id!: number & Opt;
   user!: Ref<Users>;
-  sourceVisitId!: string;
+  user_id!: number;
+  source_visit_id!: string;
   trip?: Ref<Trips> | null;
+  trip_id?: number | null;
   name!: string;
-  lat?: unknown | null;
-  lng?: unknown | null;
-  startedAt!: string;
-  endedAt!: string;
-  durationMinutes: number & Opt = 0;
-  localDate!: string;
-  sourceStatus: string & Opt = 'suggested';
-  confidence?: unknown | null;
-  confidenceBand?: string | null;
-  countryCode?: string | null;
+  lat?: number | null;
+  lng?: number | null;
+  started_at!: string;
+  ended_at!: string;
+  duration_minutes: number & Opt = 0;
+  local_date!: string;
+  source_status: string & Opt = 'suggested';
+  confidence?: number | null;
+  confidence_band?: string | null;
+  country_code?: string | null;
   state: string & Opt = 'new';
   target?: string | null;
   acceptedPlace?: Ref<Places> | null;
-  acceptedJournalEntryId?: number | null;
+  accepted_place_id?: number | null;
+  accepted_journal_entry_id?: number | null;
   acceptedBucketListItem?: Ref<BucketList> | null;
+  accepted_bucket_list_item_id?: number | null;
   matchedBucketListItem?: Ref<BucketList> | null;
-  sourceHash!: string;
-  acceptedHash?: string | null;
-  sourceMissingAt?: string | null;
-  firstSeenAt!: string & Opt;
-  lastSeenAt!: string & Opt;
+  matched_bucket_list_item_id?: number | null;
+  source_hash!: string;
+  accepted_hash?: string | null;
+  source_missing_at?: string | null;
+  first_seen_at!: string & Opt;
+  last_seen_at!: string & Opt;
 }
 
-export class DawarichVisitSuggestionsRepository extends EntityRepository<DawarichVisitSuggestions> {}
-
 export const DawarichVisitSuggestionsSchema = defineEntity({
   class: DawarichVisitSuggestions,
   repository: () => DawarichVisitSuggestionsRepository,
-  indexes: [{ name: 'idx_dawarich_suggestions_user_state', properties: ['user', 'state'] }],
+  indexes: [
+    {
+      name: 'idx_dawarich_suggestions_user_state',
+      properties: ['user_id', 'state'],
+    },
+  ],
   properties: {
-    id: p.integer().primary().autoincrement(),
-    user: () => p.manyToOne(Users).ref().deleteRule('cascade'),
-    sourceVisitId: p.text(),
-    trip: () => p.manyToOne(Trips).ref().nullable().index('idx_dawarich_suggestions_trip'),
+    id: p.integer().primary(),
+    user: () => p.manyToOne(Users).ref().deleteRule('cascade').hidden(),
+    user_id: p.integer().persist(false),
+    source_visit_id: p.text(),
+    trip: () => p.manyToOne(Trips).ref().nullable().hidden().index('idx_dawarich_suggestions_trip'),
+    trip_id: p.integer().nullable().persist(false).index('idx_dawarich_suggestions_trip'),
     name: p.text(),
     lat: p.double().nullable(),
     lng: p.double().nullable(),
-    startedAt: p.text(),
-    endedAt: p.text(),
-    durationMinutes: p.integer(),
-    localDate: p.text(),
-    sourceStatus: p.text(),
+    started_at: p.text(),
+    ended_at: p.text(),
+    duration_minutes: p.integer().default(0),
+    local_date: p.text(),
+    source_status: p.text().default('suggested'),
     confidence: p.double().nullable(),
-    confidenceBand: p.text().nullable(),
-    countryCode: p.text().nullable(),
-    state: p.text(),
+    confidence_band: p.text().nullable(),
+    country_code: p.text().nullable(),
+    state: p.text().default('new'),
     target: p.text().nullable(),
-    acceptedPlace: () => p.manyToOne(Places).ref().nullable(),
-    acceptedJournalEntryId: p.integer().nullable(),
-    acceptedBucketListItem: () => p.manyToOne(BucketList).ref().nullable(),
-    matchedBucketListItem: () => p.manyToOne(BucketList).ref().nullable(),
-    sourceHash: p.text(),
-    acceptedHash: p.text().nullable(),
-    sourceMissingAt: p.text().nullable(),
-    firstSeenAt: p.text().onCreate(() => new Date().toISOString().replace(/\.\d{3}Z$/, 'Z')),
-    lastSeenAt: p.text().onCreate(() => new Date().toISOString().replace(/\.\d{3}Z$/, 'Z')),
+    acceptedPlace: () => p.manyToOne(Places).ref().nullable().hidden(),
+    accepted_place_id: p.integer().nullable().persist(false),
+    accepted_journal_entry_id: p.integer().nullable(),
+    acceptedBucketListItem: () => p.manyToOne(BucketList).ref().nullable().hidden(),
+    accepted_bucket_list_item_id: p.integer().nullable().persist(false),
+    matchedBucketListItem: () => p.manyToOne(BucketList).ref().nullable().hidden(),
+    matched_bucket_list_item_id: p.integer().nullable().persist(false),
+    source_hash: p.text(),
+    accepted_hash: p.text().nullable(),
+    source_missing_at: p.text().nullable(),
+    first_seen_at: p.text().defaultRaw(`CURRENT_TIMESTAMP`),
+    last_seen_at: p.text().defaultRaw(`CURRENT_TIMESTAMP`),
   },
 });

server/src/db/entities/DayAccommodations.entity.ts

@@ -1,38 +1,46 @@
-import { type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { DayAccommodationsRepository } from '../repositories/DayAccommodations.repository';
+import { DbTimestampType } from '../types';
 import { Days } from './Days.entity';
 import { Places } from './Places.entity';
 import { Trips } from './Trips.entity';
 
 export class DayAccommodations {
-  id?: number | null;
+  id!: number & Opt;
   trip!: Ref<Trips>;
+  trip_id!: number;
   place?: Ref<Places> | null;
+  place_id?: number | null;
   startDay!: Ref<Days>;
+  start_day_id!: number;
   endDay!: Ref<Days>;
-  checkIn?: string | null;
-  checkInEnd?: string | null;
-  checkOut?: string | null;
+  end_day_id!: number;
+  check_in?: string | null;
+  check_in_end?: string | null;
+  check_out?: string | null;
   confirmation?: string | null;
   notes?: string | null;
-  createdAt?: Date | null;
+  created_at?: string | null;
 }
 
-export class DayAccommodationsRepository extends EntityRepository<DayAccommodations> {}
-
 export const DayAccommodationsSchema = defineEntity({
   class: DayAccommodations,
   repository: () => DayAccommodationsRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    trip: () => p.manyToOne(Trips).ref().deleteRule('cascade').index('idx_day_accommodations_trip_id'),
-    place: () => p.manyToOne(Places).ref().nullable(),
-    startDay: () => p.manyToOne(Days).ref().deleteRule('cascade').index('idx_day_accommodations_start_day_id'),
-    endDay: () => p.manyToOne(Days).ref().deleteRule('cascade').index('idx_day_accommodations_end_day_id'),
-    checkIn: p.text().nullable(),
-    checkInEnd: p.text().nullable(),
-    checkOut: p.text().nullable(),
+    id: p.integer().primary(),
+    trip: () => p.manyToOne(Trips).ref().deleteRule('cascade').hidden().index('idx_day_accommodations_trip_id'),
+    trip_id: p.integer().persist(false).index('idx_day_accommodations_trip_id'),
+    place: () => p.manyToOne(Places).ref().nullable().hidden(),
+    place_id: p.integer().nullable().persist(false),
+    startDay: () => p.manyToOne(Days).ref().deleteRule('cascade').hidden().index('idx_day_accommodations_start_day_id'),
+    start_day_id: p.integer().persist(false).index('idx_day_accommodations_start_day_id'),
+    endDay: () => p.manyToOne(Days).ref().deleteRule('cascade').hidden().index('idx_day_accommodations_end_day_id'),
+    end_day_id: p.integer().persist(false).index('idx_day_accommodations_end_day_id'),
+    check_in: p.text().nullable(),
+    check_in_end: p.text().nullable(),
+    check_out: p.text().nullable(),
     confirmation: p.text().nullable(),
     notes: p.text().nullable(),
-    createdAt: p.datetime().nullable().onCreate(() => new Date()),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
   },
 });

server/src/db/entities/DayAssignments.entity.ts

@@ -1,4 +1,6 @@
-import { Collection, type Opt, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { Collection, type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { DayAssignmentsRepository } from '../repositories/DayAssignments.repository';
+import { DbTimestampType } from '../types';
 import { AssignmentParticipants } from './AssignmentParticipants.entity';
 import { Days } from './Days.entity';
 import { FileLinks } from './FileLinks.entity';
@@ -7,53 +9,55 @@ import { Reservations } from './Reservations.entity';
 import { RoadtripDayBoundaries } from './RoadtripDayBoundaries.entity';
 
 export class DayAssignments {
-  id?: number | null;
+  id!: number & Opt;
   day!: Ref<Days>;
+  day_id!: number;
   place!: Ref<Places>;
-  orderIndex?: number | null = 0;
+  place_id!: number;
+  order_index?: number | null = 0;
   notes?: string | null;
-  reservationStatus?: string | null = 'none';
-  reservationNotes?: string | null;
-  reservationDatetime?: string | null;
-  createdAt?: Date | null;
-  assignmentTime?: string | null;
-  assignmentEndTime?: string | null;
-  legTransportMode?: string | null;
-  incomingLegTransportMode?: string | null;
-  endDay: number & Opt = 0;
-  accommodationId?: number | null;
-  assignmentParticipantsCollection = new Collection<AssignmentParticipants>(this);
-  fileLinksCollection = new Collection<FileLinks>(this);
-  reservationsCollection = new Collection<Reservations>(this);
-  roadtripDayBoundariesCollection = new Collection<RoadtripDayBoundaries>(this);
-  roadtripDayBoundariesCollection1 = new Collection<RoadtripDayBoundaries>(this);
+  reservation_status?: string | null = 'none';
+  reservation_notes?: string | null;
+  reservation_datetime?: string | null;
+  created_at?: string | null;
+  assignment_time?: string | null;
+  assignment_end_time?: string | null;
+  leg_transport_mode?: string | null;
+  incoming_leg_transport_mode?: string | null;
+  end_day: number & Opt = 0;
+  accommodation_id?: number | null;
+  assignment_participants_collection = new Collection<AssignmentParticipants>(this);
+  file_links_collection = new Collection<FileLinks>(this);
+  reservations_collection = new Collection<Reservations>(this);
+  roadtrip_day_boundaries_collection = new Collection<RoadtripDayBoundaries>(this);
+  roadtrip_day_boundaries_collection1 = new Collection<RoadtripDayBoundaries>(this);
 }
 
-export class DayAssignmentsRepository extends EntityRepository<DayAssignments> {}
-
 export const DayAssignmentsSchema = defineEntity({
   class: DayAssignments,
   repository: () => DayAssignmentsRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    day: () => p.manyToOne(Days).ref().deleteRule('cascade').index('idx_day_assignments_day_id'),
-    place: () => p.manyToOne(Places).ref().deleteRule('cascade').index('idx_day_assignments_place_id'),
-    orderIndex: p.integer().nullable(),
+    id: p.integer().primary(),
+    day: () => p.manyToOne(Days).ref().deleteRule('cascade').hidden().index('idx_day_assignments_day_id'),
+    day_id: p.integer().persist(false).index('idx_day_assignments_day_id'),
+    place: () => p.manyToOne(Places).ref().deleteRule('cascade').hidden().index('idx_day_assignments_place_id'),
+    place_id: p.integer().persist(false).index('idx_day_assignments_place_id'),
+    order_index: p.integer().nullable(),
     notes: p.text().nullable(),
-    reservationStatus: p.text().nullable(),
-    reservationNotes: p.text().nullable(),
-    reservationDatetime: p.text().nullable(),
-    createdAt: p.datetime().nullable().onCreate(() => new Date()),
-    assignmentTime: p.text().nullable(),
-    assignmentEndTime: p.text().nullable(),
-    legTransportMode: p.text().nullable(),
-    incomingLegTransportMode: p.text().nullable(),
-    endDay: p.integer(),
-    accommodationId: p.integer().nullable().index('idx_day_assignments_accommodation_id'),
-    assignmentParticipantsCollection: () => p.oneToMany(AssignmentParticipants).mappedBy('assignment'),
-    fileLinksCollection: () => p.oneToMany(FileLinks).mappedBy('assignment'),
-    reservationsCollection: () => p.oneToMany(Reservations).mappedBy('assignment'),
-    roadtripDayBoundariesCollection: () => p.oneToMany(RoadtripDayBoundaries).mappedBy('fromAssignment'),
-    roadtripDayBoundariesCollection1: () => p.oneToMany(RoadtripDayBoundaries).mappedBy('toAssignment'),
+    reservation_status: p.text().nullable(),
+    reservation_notes: p.text().nullable(),
+    reservation_datetime: p.text().nullable(),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
+    assignment_time: p.text().nullable(),
+    assignment_end_time: p.text().nullable(),
+    leg_transport_mode: p.text().nullable(),
+    incoming_leg_transport_mode: p.text().nullable(),
+    end_day: p.integer().default(0),
+    accommodation_id: p.integer().nullable().index('idx_day_assignments_accommodation_id'),
+    assignment_participants_collection: () => p.oneToMany(AssignmentParticipants).mappedBy('assignment').hidden(),
+    file_links_collection: () => p.oneToMany(FileLinks).mappedBy('assignment').hidden(),
+    reservations_collection: () => p.oneToMany(Reservations).mappedBy('assignment').hidden(),
+    roadtrip_day_boundaries_collection: () => p.oneToMany(RoadtripDayBoundaries).mappedBy('fromAssignment').hidden(),
+    roadtrip_day_boundaries_collection1: () => p.oneToMany(RoadtripDayBoundaries).mappedBy('toAssignment').hidden(),
   },
 });

server/src/db/entities/DayNotes.entity.ts

@@ -1,11 +1,11 @@
-import { type Ref, defineEntity, p } from '@mikro-orm/core';
+import { type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
 import { DayNotesRepository } from '../repositories/DayNotes.repository';
 import { DbTimestampType } from '../types';
 import { Days } from './Days.entity';
 import { Trips } from './Trips.entity';
 
 export class DayNotes {
-  id?: number | null;
+  id!: number & Opt;
   day!: Ref<Days>;
   day_id!: number;
   trip!: Ref<Trips>;
@@ -22,16 +22,16 @@ export const DayNotesSchema = defineEntity({
   class: DayNotes,
   repository: () => DayNotesRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    day: () => p.manyToOne(Days).ref().hidden().deleteRule('cascade').index('idx_day_notes_day_id'),
-    day_id: p.integer().persist(false),
-    trip: () => p.manyToOne(Trips).ref().hidden().deleteRule('cascade'),
+    id: p.integer().primary(),
+    day: () => p.manyToOne(Days).ref().deleteRule('cascade').hidden().index('idx_day_notes_day_id'),
+    day_id: p.integer().persist(false).index('idx_day_notes_day_id'),
+    trip: () => p.manyToOne(Trips).ref().deleteRule('cascade').hidden(),
     trip_id: p.integer().persist(false),
     text: p.text(),
     time: p.text().nullable(),
     icon: p.text().nullable(),
-    sort_order: p.double().nullable().default(0),
-    created_at: p.type(DbTimestampType).nullable().defaultRaw('CURRENT_TIMESTAMP'),
+    sort_order: p.double().nullable().defaultRaw(`0`),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
     color: p.text().nullable(),
   },
 });

server/src/db/entities/Days.entity.ts

@@ -1,4 +1,4 @@
-import { Collection, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { Collection, type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
 import { DaysRepository } from '../repositories/Days.repository';
 import { DayAccommodations } from './DayAccommodations.entity';
 import { DayAssignments } from './DayAssignments.entity';
@@ -11,7 +11,7 @@ import { RoadtripVias } from './RoadtripVias.entity';
 import { Trips } from './Trips.entity';
 
 export class Days {
-  id?: number | null;
+  id!: number & Opt;
   trip!: Ref<Trips>;
   trip_id!: number;
   day_number!: number;
@@ -35,23 +35,23 @@ export const DaysSchema = defineEntity({
   class: Days,
   repository: () => DaysRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    trip: () => p.manyToOne(Trips).ref().hidden().deleteRule('cascade').index('idx_days_trip_id'),
-    trip_id: p.integer().persist(false),
+    id: p.integer().primary(),
+    trip: () => p.manyToOne(Trips).ref().deleteRule('cascade').hidden().index('idx_days_trip_id'),
+    trip_id: p.integer().persist(false).index('idx_days_trip_id'),
     day_number: p.integer(),
     date: p.text().nullable(),
     notes: p.text().nullable(),
     title: p.text().nullable(),
     default_transport_mode: p.text().nullable(),
-    day_accommodations_collection: () => p.oneToMany(DayAccommodations).hidden().mappedBy('startDay'),
-    day_accommodations_collection1: () => p.oneToMany(DayAccommodations).hidden().mappedBy('endDay'),
-    day_assignments_collection: () => p.oneToMany(DayAssignments).hidden().mappedBy('day'),
-    day_notes_collection: () => p.oneToMany(DayNotes).hidden().mappedBy('day'),
-    photos_collection: () => p.oneToMany(Photos).hidden().mappedBy('day'),
-    reservation_day_positions_collection: () => p.oneToMany(ReservationDayPositions).hidden().mappedBy('day'),
-    reservations_collection: () => p.oneToMany(Reservations).hidden().mappedBy('day'),
-    reservations_collection1: () => p.oneToMany(Reservations).hidden().mappedBy('endDay'),
-    roadtrip_day_tracks: () => p.oneToOne(RoadtripDayTracks).ref().hidden().mappedBy('day'),
-    roadtrip_vias_collection: () => p.oneToMany(RoadtripVias).hidden().mappedBy('day'),
+    day_accommodations_collection: () => p.oneToMany(DayAccommodations).mappedBy('startDay').hidden(),
+    day_accommodations_collection1: () => p.oneToMany(DayAccommodations).mappedBy('endDay').hidden(),
+    day_assignments_collection: () => p.oneToMany(DayAssignments).mappedBy('day').hidden(),
+    day_notes_collection: () => p.oneToMany(DayNotes).mappedBy('day').hidden(),
+    photos_collection: () => p.oneToMany(Photos).mappedBy('day').hidden(),
+    reservation_day_positions_collection: () => p.oneToMany(ReservationDayPositions).mappedBy('day').hidden(),
+    reservations_collection: () => p.oneToMany(Reservations).mappedBy('day').hidden(),
+    reservations_collection1: () => p.oneToMany(Reservations).mappedBy('endDay').hidden(),
+    roadtrip_day_tracks: () => p.oneToOne(RoadtripDayTracks).ref().mappedBy('day').hidden(),
+    roadtrip_vias_collection: () => p.oneToMany(RoadtripVias).mappedBy('day').hidden(),
   },
 });

server/src/db/entities/DocumentConnections.entity.ts

@@ -0,0 +1,53 @@
+import { Collection, type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { DocumentConnectionsRepository } from '../repositories/DocumentConnections.repository';
+import { DbTimestampType } from '../types';
+import { DocumentProviders } from './DocumentProviders.entity';
+import { TripDocumentLinks } from './TripDocumentLinks.entity';
+import { Trips } from './Trips.entity';
+import { Users } from './Users.entity';
+
+export class DocumentConnections {
+  id!: number & Opt;
+  trip!: Ref<Trips>;
+  trip_id!: number;
+  provider!: Ref<DocumentProviders>;
+  provider_id!: string;
+  ownerUser!: Ref<Users>;
+  owner_user_id!: number;
+  base_url!: string;
+  secrets?: string | null;
+  settings: string & Opt = '{}';
+  allow_insecure_tls: number & Opt = 0;
+  capabilities?: string | null;
+  last_probe_at?: string | null;
+  last_probe_state: string & Opt = 'never';
+  last_probe_error?: string | null;
+  created_at?: string | null;
+  updated_at?: string | null;
+  trip_document_links_collection = new Collection<TripDocumentLinks>(this);
+}
+
+export const DocumentConnectionsSchema = defineEntity({
+  class: DocumentConnections,
+  repository: () => DocumentConnectionsRepository,
+  properties: {
+    id: p.integer().primary(),
+    trip: () => p.manyToOne(Trips).ref().deleteRule('cascade').hidden().index('idx_document_connections_trip'),
+    trip_id: p.integer().persist(false).index('idx_document_connections_trip'),
+    provider: () => p.manyToOne(DocumentProviders).ref().deleteRule('cascade').hidden(),
+    provider_id: p.text().persist(false),
+    ownerUser: () => p.manyToOne(Users).ref().deleteRule('cascade').hidden().index('idx_document_connections_owner'),
+    owner_user_id: p.integer().persist(false).index('idx_document_connections_owner'),
+    base_url: p.text(),
+    secrets: p.text().nullable(),
+    settings: p.text().default('{}'),
+    allow_insecure_tls: p.integer().default(0),
+    capabilities: p.text().nullable(),
+    last_probe_at: p.text().nullable(),
+    last_probe_state: p.text().default('never'),
+    last_probe_error: p.text().nullable(),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
+    updated_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
+    trip_document_links_collection: () => p.oneToMany(TripDocumentLinks).mappedBy('connection').hidden(),
+  },
+});

server/src/db/entities/DocumentProviderFields.entity.ts

@@ -0,0 +1,35 @@
+import { type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { DocumentProviderFieldsRepository } from '../repositories/DocumentProviderFields.repository';
+import { DocumentProviders } from './DocumentProviders.entity';
+
+export class DocumentProviderFields {
+  id!: number & Opt;
+  provider!: Ref<DocumentProviders>;
+  provider_id!: string;
+  field_key!: string;
+  label!: string;
+  input_type: string & Opt = 'text';
+  placeholder?: string | null;
+  hint?: string | null;
+  required?: number | null = 0;
+  secret?: number | null = 0;
+  sort_order?: number | null = 0;
+}
+
+export const DocumentProviderFieldsSchema = defineEntity({
+  class: DocumentProviderFields,
+  repository: () => DocumentProviderFieldsRepository,
+  properties: {
+    id: p.integer().primary(),
+    provider: () => p.manyToOne(DocumentProviders).ref().deleteRule('cascade').hidden(),
+    provider_id: p.text().persist(false),
+    field_key: p.text(),
+    label: p.text(),
+    input_type: p.text().default('text'),
+    placeholder: p.text().nullable(),
+    hint: p.text().nullable(),
+    required: p.integer().nullable(),
+    secret: p.integer().nullable(),
+    sort_order: p.integer().nullable(),
+  },
+});

server/src/db/entities/DocumentProviders.entity.ts

@@ -0,0 +1,30 @@
+import { Collection, defineEntity, p } from '@mikro-orm/core';
+import { DocumentProvidersRepository } from '../repositories/DocumentProviders.repository';
+import { DocumentConnections } from './DocumentConnections.entity';
+import { DocumentProviderFields } from './DocumentProviderFields.entity';
+
+export class DocumentProviders {
+  id?: string | null;
+  name!: string;
+  description?: string | null;
+  icon?: string | null = 'FileText';
+  enabled?: number | null = 0;
+  sort_order?: number | null = 0;
+  document_connections_collection = new Collection<DocumentConnections>(this);
+  document_provider_fields_collection = new Collection<DocumentProviderFields>(this);
+}
+
+export const DocumentProvidersSchema = defineEntity({
+  class: DocumentProviders,
+  repository: () => DocumentProvidersRepository,
+  properties: {
+    id: p.text().primary().nullable(),
+    name: p.text(),
+    description: p.text().nullable(),
+    icon: p.text().nullable(),
+    enabled: p.integer().nullable(),
+    sort_order: p.integer().nullable(),
+    document_connections_collection: () => p.oneToMany(DocumentConnections).mappedBy('provider').hidden(),
+    document_provider_fields_collection: () => p.oneToMany(DocumentProviderFields).mappedBy('provider').hidden(),
+  },
+});

server/src/db/entities/DocumentSyncItems.entity.ts

@@ -0,0 +1,93 @@
+import { type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { DocumentSyncItemsRepository } from '../repositories/DocumentSyncItems.repository';
+import { TripDocumentLinks } from './TripDocumentLinks.entity';
+import { TripFiles } from './TripFiles.entity';
+import { Trips } from './Trips.entity';
+
+export class DocumentSyncItems {
+  id!: number & Opt;
+  link!: Ref<TripDocumentLinks>;
+  link_id!: number;
+  trip!: Ref<Trips>;
+  trip_id!: number;
+  file?: Ref<TripFiles> | null;
+  file_id?: number | null;
+  trek_doc_uid!: string;
+  remote_id?: string | null;
+  remote_name?: string | null;
+  remote_version?: string | null;
+  remote_size?: number | null;
+  remote_modified_at?: string | null;
+  content_sha256?: string | null;
+  pushed_sha256?: string | null;
+  state: string & Opt = 'pending';
+  error_code?: string | null;
+  attempts: number & Opt = 0;
+  next_attempt_at?: string | null;
+  remote_missing_at?: string | null;
+  first_seen_at!: string & Opt;
+  last_seen_at!: string & Opt;
+  synced_at?: string | null;
+  remote_trashed_at?: string | null;
+}
+
+export const DocumentSyncItemsSchema = defineEntity({
+  class: DocumentSyncItems,
+  repository: () => DocumentSyncItemsRepository,
+  indexes: [
+    {
+      name: 'idx_document_sync_items_due',
+      properties: ['link_id', 'next_attempt_at'],
+    },
+    {
+      name: 'idx_document_sync_items_hash',
+      properties: ['link_id', 'content_sha256'],
+    },
+    {
+      name: 'idx_document_sync_items_trip_state',
+      properties: ['trip_id', 'state'],
+    },
+  ],
+  uniques: [
+    {
+      name: 'idx_document_sync_items_uid',
+      properties: ['link_id', 'trek_doc_uid'],
+    },
+    {
+      name: 'idx_document_sync_items_file',
+      where: 'file_id IS NOT NULL',
+      properties: ['link_id', 'file_id'],
+    },
+    {
+      name: 'idx_document_sync_items_remote',
+      where: 'remote_id IS NOT NULL',
+      properties: ['link_id', 'remote_id'],
+    },
+  ],
+  properties: {
+    id: p.integer().primary(),
+    link: () => p.manyToOne(TripDocumentLinks).ref().deleteRule('cascade').hidden(),
+    link_id: p.integer().persist(false),
+    trip: () => p.manyToOne(Trips).ref().deleteRule('cascade').hidden(),
+    trip_id: p.integer().persist(false),
+    file: () => p.manyToOne(TripFiles).ref().nullable().hidden(),
+    file_id: p.integer().nullable().persist(false),
+    trek_doc_uid: p.text(),
+    remote_id: p.text().nullable(),
+    remote_name: p.text().nullable(),
+    remote_version: p.text().nullable(),
+    remote_size: p.integer().nullable(),
+    remote_modified_at: p.text().nullable(),
+    content_sha256: p.text().nullable(),
+    pushed_sha256: p.text().nullable(),
+    state: p.text().default('pending'),
+    error_code: p.text().nullable(),
+    attempts: p.integer().default(0),
+    next_attempt_at: p.text().nullable(),
+    remote_missing_at: p.text().nullable(),
+    first_seen_at: p.text().defaultRaw(`CURRENT_TIMESTAMP`),
+    last_seen_at: p.text().defaultRaw(`CURRENT_TIMESTAMP`),
+    synced_at: p.text().nullable(),
+    remote_trashed_at: p.text().nullable(),
+  },
+});

server/src/db/entities/FileLinks.entity.ts

@@ -1,4 +1,6 @@
-import { type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { FileLinksRepository } from '../repositories/FileLinks.repository';
+import { DbTimestampType } from '../types';
 import { BudgetItems } from './BudgetItems.entity';
 import { DayAssignments } from './DayAssignments.entity';
 import { Places } from './Places.entity';
@@ -6,30 +8,41 @@ import { Reservations } from './Reservations.entity';
 import { TripFiles } from './TripFiles.entity';
 
 export class FileLinks {
-  id?: number | null;
+  id!: number & Opt;
   file!: Ref<TripFiles>;
+  file_id!: number;
   reservation?: Ref<Reservations> | null;
+  reservation_id?: number | null;
   assignment?: Ref<DayAssignments> | null;
+  assignment_id?: number | null;
   place?: Ref<Places> | null;
-  createdAt?: Date | null;
+  place_id?: number | null;
+  created_at?: string | null;
   budgetItem?: Ref<BudgetItems> | null;
+  budget_item_id?: number | null;
 }
 
-export class FileLinksRepository extends EntityRepository<FileLinks> {}
-
 export const FileLinksSchema = defineEntity({
   class: FileLinks,
   repository: () => FileLinksRepository,
   uniques: [
-    { name: 'idx_file_links_file_budget', properties: ['file', 'budgetItem'] },
+    {
+      name: 'idx_file_links_file_budget',
+      properties: ['file_id', 'budget_item_id'],
+    },
   ],
   properties: {
-    id: p.integer().primary().autoincrement(),
-    file: () => p.manyToOne(TripFiles).ref().deleteRule('cascade'),
-    reservation: () => p.manyToOne(Reservations).ref().deleteRule('cascade').nullable(),
-    assignment: () => p.manyToOne(DayAssignments).ref().deleteRule('cascade').nullable(),
-    place: () => p.manyToOne(Places).ref().deleteRule('cascade').nullable(),
-    createdAt: p.datetime().nullable().onCreate(() => new Date()),
-    budgetItem: () => p.manyToOne(BudgetItems).ref().nullable().index('idx_file_links_budget_item_id'),
+    id: p.integer().primary(),
+    file: () => p.manyToOne(TripFiles).ref().deleteRule('cascade').hidden(),
+    file_id: p.integer().persist(false),
+    reservation: () => p.manyToOne(Reservations).ref().deleteRule('cascade').nullable().hidden(),
+    reservation_id: p.integer().nullable().persist(false),
+    assignment: () => p.manyToOne(DayAssignments).ref().deleteRule('cascade').nullable().hidden(),
+    assignment_id: p.integer().nullable().persist(false),
+    place: () => p.manyToOne(Places).ref().deleteRule('cascade').nullable().hidden(),
+    place_id: p.integer().nullable().persist(false),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
+    budgetItem: () => p.manyToOne(BudgetItems).ref().nullable().hidden().index('idx_file_links_budget_item_id'),
+    budget_item_id: p.integer().nullable().persist(false).index('idx_file_links_budget_item_id'),
   },
 });

server/src/db/entities/GooglePlacePhotoMeta.entity.ts

@@ -1,22 +1,21 @@
-import { PrimaryKeyProp, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { PrimaryKeyProp, defineEntity, p } from '@mikro-orm/core';
+import { GooglePlacePhotoMetaRepository } from '../repositories/GooglePlacePhotoMeta.repository';
 
 export class GooglePlacePhotoMeta {
-  [PrimaryKeyProp]?: 'placeId';
-  placeId?: string | null;
+  [PrimaryKeyProp]?: 'place_id';
+  place_id?: string | null;
   attribution?: string | null;
-  fetchedAt!: number;
-  errorAt?: number | null;
+  fetched_at!: number;
+  error_at?: number | null;
 }
 
-export class GooglePlacePhotoMetaRepository extends EntityRepository<GooglePlacePhotoMeta> {}
-
 export const GooglePlacePhotoMetaSchema = defineEntity({
   class: GooglePlacePhotoMeta,
   repository: () => GooglePlacePhotoMetaRepository,
   properties: {
-    placeId: p.text().primary().nullable(),
+    place_id: p.text().primary().nullable(),
     attribution: p.text().nullable(),
-    fetchedAt: p.integer(),
-    errorAt: p.integer().nullable(),
+    fetched_at: p.integer(),
+    error_at: p.integer().nullable(),
   },
 });

server/src/db/entities/HiddenCountries.entity.ts

@@ -1,22 +1,24 @@
-import { type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { HiddenCountriesRepository } from '../repositories/HiddenCountries.repository';
+import { DbTimestampType } from '../types';
 import { Users } from './Users.entity';
 
 export class HiddenCountries {
-  id?: number | null;
+  id!: number & Opt;
   user!: Ref<Users>;
-  countryCode!: string;
-  createdAt?: Date | null;
+  user_id!: number;
+  country_code!: string;
+  created_at?: string | null;
 }
 
-export class HiddenCountriesRepository extends EntityRepository<HiddenCountries> {}
-
 export const HiddenCountriesSchema = defineEntity({
   class: HiddenCountries,
   repository: () => HiddenCountriesRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    user: () => p.manyToOne(Users).ref().deleteRule('cascade').index('idx_hidden_countries_user'),
-    countryCode: p.text(),
-    createdAt: p.datetime().nullable().onCreate(() => new Date()),
+    id: p.integer().primary(),
+    user: () => p.manyToOne(Users).ref().deleteRule('cascade').hidden().index('idx_hidden_countries_user'),
+    user_id: p.integer().persist(false).index('idx_hidden_countries_user'),
+    country_code: p.text(),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
   },
 });

server/src/db/entities/HiddenRegions.entity.ts

@@ -1,24 +1,26 @@
-import { type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { HiddenRegionsRepository } from '../repositories/HiddenRegions.repository';
+import { DbTimestampType } from '../types';
 import { Users } from './Users.entity';
 
 export class HiddenRegions {
-  id?: number | null;
+  id!: number & Opt;
   user!: Ref<Users>;
-  regionCode!: string;
-  countryCode!: string;
-  createdAt?: Date | null;
+  user_id!: number;
+  region_code!: string;
+  country_code!: string;
+  created_at?: string | null;
 }
 
-export class HiddenRegionsRepository extends EntityRepository<HiddenRegions> {}
-
 export const HiddenRegionsSchema = defineEntity({
   class: HiddenRegions,
   repository: () => HiddenRegionsRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    user: () => p.manyToOne(Users).ref().deleteRule('cascade').index('idx_hidden_regions_user'),
-    regionCode: p.text(),
-    countryCode: p.text(),
-    createdAt: p.datetime().nullable().onCreate(() => new Date()),
+    id: p.integer().primary(),
+    user: () => p.manyToOne(Users).ref().deleteRule('cascade').hidden().index('idx_hidden_regions_user'),
+    user_id: p.integer().persist(false).index('idx_hidden_regions_user'),
+    region_code: p.text(),
+    country_code: p.text(),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
   },
 });

server/src/db/entities/IdempotencyKeys.entity.ts

@@ -1,29 +1,30 @@
-import { type Opt, PrimaryKeyProp, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, PrimaryKeyProp, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { IdempotencyKeysRepository } from '../repositories/IdempotencyKeys.repository';
 import { Users } from './Users.entity';
 
 export class IdempotencyKeys {
   [PrimaryKeyProp]?: ['key', 'user', 'method', 'path'];
   key!: string;
   user!: Ref<Users>;
+  user_id!: number;
   method!: string;
   path!: string;
-  statusCode!: number;
-  responseBody!: string;
-  createdAt: number & Opt = NaN;
+  status_code!: number;
+  response_body!: string;
+  created_at: number & Opt = NaN;
 }
 
-export class IdempotencyKeysRepository extends EntityRepository<IdempotencyKeys> {}
-
 export const IdempotencyKeysSchema = defineEntity({
   class: IdempotencyKeys,
   repository: () => IdempotencyKeysRepository,
   properties: {
     key: p.text().primary(),
-    user: () => p.manyToOne(Users).primary().ref().deleteRule('cascade'),
+    user: () => p.manyToOne(Users).primary().ref().deleteRule('cascade').hidden(),
+    user_id: p.integer().persist(false),
     method: p.text().primary(),
     path: p.text().primary(),
-    statusCode: p.integer(),
-    responseBody: p.text(),
-    createdAt: p.integer().defaultRaw(`(strftime('%s','now'))`).index('idx_idempotency_keys_created'),
+    status_code: p.integer(),
+    response_body: p.text(),
+    created_at: p.integer().defaultRaw(`(strftime('%s','now'))`).index('idx_idempotency_keys_created'),
   },
 });

server/src/db/entities/InviteTokens.entity.ts

@@ -1,31 +1,35 @@
-import { type Opt, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { InviteTokensRepository } from '../repositories/InviteTokens.repository';
+import { DbTimestampType } from '../types';
 import { Trips } from './Trips.entity';
 import { Users } from './Users.entity';
 
 export class InviteTokens {
-  id?: number | null;
+  id!: number & Opt;
   token!: string;
-  maxUses: number & Opt = 1;
-  usedCount: number & Opt = 0;
-  expiresAt?: string | null;
-  createdBy!: Ref<Users>;
-  createdAt?: Date | null;
+  max_uses: number & Opt = 1;
+  used_count: number & Opt = 0;
+  expires_at?: string | null;
+  created_by!: number;
+  created_at?: string | null;
   trip?: Ref<Trips> | null;
+  trip_id?: number | null;
+  createdByRef!: Ref<Users>;
 }
 
-export class InviteTokensRepository extends EntityRepository<InviteTokens> {}
-
 export const InviteTokensSchema = defineEntity({
   class: InviteTokens,
   repository: () => InviteTokensRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
+    id: p.integer().primary(),
     token: p.text(),
-    maxUses: p.integer(),
-    usedCount: p.integer(),
-    expiresAt: p.text().nullable(),
-    createdBy: () => p.manyToOne(Users).ref().name('created_by').deleteRule('cascade'),
-    createdAt: p.datetime().nullable().onCreate(() => new Date()),
-    trip: () => p.manyToOne(Trips).ref().nullable(),
+    max_uses: p.integer().default(1),
+    used_count: p.integer().default(0),
+    expires_at: p.text().nullable(),
+    created_by: p.integer().persist(false),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
+    trip: () => p.manyToOne(Trips).ref().nullable().hidden(),
+    trip_id: p.integer().nullable().persist(false),
+    createdByRef: () => p.manyToOne(Users).ref().joinColumn('created_by').deleteRule('cascade').hidden(),
   },
 });

server/src/db/entities/JourneyBooks.entity.ts

@@ -1,33 +1,39 @@
-import { type Opt, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { JourneyBooksRepository } from '../repositories/JourneyBooks.repository';
+import { DbTimestampType } from '../types';
 import { Journeys } from './Journeys.entity';
 import { Users } from './Users.entity';
 
 export class JourneyBooks {
-  id?: number | null;
+  id!: number & Opt;
   journey!: Ref<Journeys>;
+  journey_id!: number;
   title: string & Opt = '';
   document!: string;
   version: number & Opt = 1;
-  createdBy?: Ref<Users> | null;
-  updatedBy?: Ref<Users> | null;
-  createdAt?: Date | null;
-  updatedAt?: Date | null;
+  created_by?: number | null;
+  updated_by?: number | null;
+  created_at?: string | null;
+  updated_at?: string | null;
+  updatedByRef?: Ref<Users> | null;
+  createdByRef?: Ref<Users> | null;
 }
 
-export class JourneyBooksRepository extends EntityRepository<JourneyBooks> {}
-
 export const JourneyBooksSchema = defineEntity({
   class: JourneyBooks,
   repository: () => JourneyBooksRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    journey: () => p.manyToOne(Journeys).ref().deleteRule('cascade').index('idx_journey_books_journey'),
-    title: p.text(),
+    id: p.integer().primary(),
+    journey: () => p.manyToOne(Journeys).ref().deleteRule('cascade').hidden().index('idx_journey_books_journey'),
+    journey_id: p.integer().persist(false).index('idx_journey_books_journey'),
+    title: p.text().default(''),
     document: p.text(),
-    version: p.integer(),
-    createdBy: () => p.manyToOne(Users).ref().name('created_by').nullable(),
-    updatedBy: () => p.manyToOne(Users).ref().name('updated_by').nullable(),
-    createdAt: p.datetime().nullable().onCreate(() => new Date()),
-    updatedAt: p.datetime().nullable().onCreate(() => new Date()),
+    version: p.integer().default(1),
+    created_by: p.integer().nullable().persist(false),
+    updated_by: p.integer().nullable().persist(false),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
+    updated_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
+    updatedByRef: () => p.manyToOne(Users).ref().joinColumn('updated_by').nullable().hidden(),
+    createdByRef: () => p.manyToOne(Users).ref().joinColumn('created_by').nullable().hidden(),
   },
 });

server/src/db/entities/JourneyContributors.entity.ts

@@ -1,26 +1,29 @@
-import { type Opt, PrimaryKeyProp, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, PrimaryKeyProp, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { JourneyContributorsRepository } from '../repositories/JourneyContributors.repository';
 import { Journeys } from './Journeys.entity';
 import { Users } from './Users.entity';
 
 export class JourneyContributors {
   [PrimaryKeyProp]?: ['journey', 'user'];
   journey!: Ref<Journeys>;
+  journey_id!: number;
   user!: Ref<Users>;
+  user_id!: number;
   role!: string;
-  addedAt!: number;
-  hideSkeletons: number & Opt = 0;
+  added_at!: number;
+  hide_skeletons: number & Opt = 0;
 }
 
-export class JourneyContributorsRepository extends EntityRepository<JourneyContributors> {}
-
 export const JourneyContributorsSchema = defineEntity({
   class: JourneyContributors,
   repository: () => JourneyContributorsRepository,
   properties: {
-    journey: () => p.manyToOne(Journeys).primary().ref(),
-    user: () => p.manyToOne(Users).primary().ref().index('idx_journey_contributors_user'),
+    journey: () => p.manyToOne(Journeys).primary().ref().hidden(),
+    journey_id: p.integer().persist(false),
+    user: () => p.manyToOne(Users).primary().ref().hidden().index('idx_journey_contributors_user'),
+    user_id: p.integer().persist(false).index('idx_journey_contributors_user'),
     role: p.text(),
-    addedAt: p.integer(),
-    hideSkeletons: p.integer(),
+    added_at: p.integer(),
+    hide_skeletons: p.integer().default(0),
   },
 });

server/src/db/entities/JourneyEntries.entity.ts

@@ -1,4 +1,5 @@
-import { Collection, type Opt, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { Collection, type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { JourneyEntriesRepository } from '../repositories/JourneyEntries.repository';
 import { JourneyEntryPhotos } from './JourneyEntryPhotos.entity';
 import { Journeys } from './Journeys.entity';
 import { Places } from './Places.entity';
@@ -6,76 +7,85 @@ import { Trips } from './Trips.entity';
 import { Users } from './Users.entity';
 
 export class JourneyEntries {
-  id?: number | null;
+  id!: number & Opt;
   journey!: Ref<Journeys>;
+  journey_id!: number;
   sourceTrip?: Ref<Trips> | null;
+  source_trip_id?: number | null;
   sourcePlace?: Ref<Places> | null;
+  source_place_id?: number | null;
   author!: Ref<Users>;
+  author_id!: number;
   type!: string;
   title?: string | null;
   story?: string | null;
-  entryDate!: string;
-  entryTime?: string | null;
-  locationName?: string | null;
-  locationLat?: unknown | null;
-  locationLng?: unknown | null;
+  entry_date!: string;
+  entry_time?: string | null;
+  location_name?: string | null;
+  location_lat?: number | null;
+  location_lng?: number | null;
   mood?: string | null;
   weather?: string | null;
   tags?: string | null;
   visibility?: string | null = 'private';
-  sortOrder?: number | null = 0;
-  createdAt!: number;
-  updatedAt!: number;
-  prosCons?: string | null;
-  statsExcluded: number & Opt = 0;
+  sort_order?: number | null = 0;
+  created_at!: number;
+  updated_at!: number;
+  pros_cons?: string | null;
+  stats_excluded: number & Opt = 0;
   dismissed: number & Opt = 0;
-  countryCode?: string | null;
-  sourceAssignmentId?: number | null;
-  journeyEntryPhotosCollection = new Collection<JourneyEntryPhotos>(this);
+  country_code?: string | null;
+  source_assignment_id?: number | null;
+  journey_entry_photos_collection = new Collection<JourneyEntryPhotos>(this);
 }
 
-export class JourneyEntriesRepository extends EntityRepository<JourneyEntries> {}
-
 export const JourneyEntriesSchema = defineEntity({
   class: JourneyEntries,
   repository: () => JourneyEntriesRepository,
   indexes: [
     {
       name: 'idx_journey_entries_source_assignment',
-      properties: ['sourcePlace', 'sourceAssignmentId'],
+      properties: ['source_place_id', 'source_assignment_id'],
     },
     {
       name: 'idx_journey_entries_order',
-      properties: ['journey', 'entryDate', 'sortOrder'],
+      properties: ['journey_id', 'entry_date', 'sort_order'],
+    },
+    {
+      name: 'idx_journey_entries_journey',
+      properties: ['journey_id', 'entry_date'],
     },
-    { name: 'idx_journey_entries_journey', properties: ['journey', 'entryDate'] },
   ],
   properties: {
-    id: p.integer().primary().autoincrement(),
-    journey: () => p.manyToOne(Journeys).ref().deleteRule('cascade'),
-    sourceTrip: () => p.manyToOne(Trips).ref().nullable(),
-    sourcePlace: () => p.manyToOne(Places).ref().nullable().index('idx_journey_entries_source'),
-    author: () => p.manyToOne(Users).ref(),
+    id: p.integer().primary(),
+    journey: () => p.manyToOne(Journeys).ref().deleteRule('cascade').hidden(),
+    journey_id: p.integer().persist(false),
+    sourceTrip: () => p.manyToOne(Trips).ref().nullable().hidden(),
+    source_trip_id: p.integer().nullable().persist(false),
+    sourcePlace: () => p.manyToOne(Places).ref().nullable().hidden().index('idx_journey_entries_source'),
+    source_place_id: p.integer().nullable().persist(false).index('idx_journey_entries_source'),
+    author: () => p.manyToOne(Users).ref().hidden(),
+    author_id: p.integer().persist(false),
     type: p.text(),
     title: p.text().nullable(),
     story: p.text().nullable(),
-    entryDate: p.text(),
-    entryTime: p.text().nullable(),
-    locationName: p.text().nullable(),
-    locationLat: p.double().nullable(),
-    locationLng: p.double().nullable(),
+    entry_date: p.text(),
+    entry_time: p.text().nullable(),
+    location_name: p.text().nullable(),
+    location_lat: p.double().nullable(),
+    location_lng: p.double().nullable(),
     mood: p.text().nullable(),
     weather: p.text().nullable(),
     tags: p.text().nullable(),
     visibility: p.text().nullable(),
-    sortOrder: p.integer().nullable(),
-    createdAt: p.integer(),
-    updatedAt: p.integer(),
-    prosCons: p.text().nullable(),
-    statsExcluded: p.integer(),
-    dismissed: p.integer(),
-    countryCode: p.text().nullable(),
-    sourceAssignmentId: p.integer().nullable(),
-    journeyEntryPhotosCollection: () => p.oneToMany(JourneyEntryPhotos).mappedBy('entry'),
+    sort_order: p.integer().nullable(),
+    created_at: p.integer(),
+    updated_at: p.integer(),
+    pros_cons: p.text().nullable(),
+    stats_excluded: p.integer().default(0),
+    dismissed: p.integer().default(0),
+    country_code: p.text().nullable(),
+    source_assignment_id: p.integer().nullable(),
+    journey_entry_photos_collection: () => p.oneToMany(JourneyEntryPhotos).mappedBy('entry').hidden(),
   },
 });

server/src/db/entities/JourneyEntryPhotos.entity.ts

@@ -1,24 +1,27 @@
-import { PrimaryKeyProp, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { PrimaryKeyProp, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { JourneyEntryPhotosRepository } from '../repositories/JourneyEntryPhotos.repository';
 import { JourneyEntries } from './JourneyEntries.entity';
 import { JourneyPhotos } from './JourneyPhotos.entity';
 
 export class JourneyEntryPhotos {
   [PrimaryKeyProp]?: ['entry', 'journeyPhoto'];
   entry!: Ref<JourneyEntries>;
+  entry_id!: number;
   journeyPhoto!: Ref<JourneyPhotos>;
-  sortOrder?: number | null = 0;
-  createdAt!: number;
+  journey_photo_id!: number;
+  sort_order?: number | null = 0;
+  created_at!: number;
 }
 
-export class JourneyEntryPhotosRepository extends EntityRepository<JourneyEntryPhotos> {}
-
 export const JourneyEntryPhotosSchema = defineEntity({
   class: JourneyEntryPhotos,
   repository: () => JourneyEntryPhotosRepository,
   properties: {
-    entry: () => p.manyToOne(JourneyEntries).primary().ref().index('idx_journey_entry_photos_entry'),
-    journeyPhoto: () => p.manyToOne(JourneyPhotos).primary().ref().index('idx_journey_entry_photos_photo'),
-    sortOrder: p.integer().nullable(),
-    createdAt: p.integer(),
+    entry: () => p.manyToOne(JourneyEntries).primary().ref().hidden().index('idx_journey_entry_photos_entry'),
+    entry_id: p.integer().persist(false).index('idx_journey_entry_photos_entry'),
+    journeyPhoto: () => p.manyToOne(JourneyPhotos).primary().ref().hidden().index('idx_journey_entry_photos_photo'),
+    journey_photo_id: p.integer().persist(false).index('idx_journey_entry_photos_photo'),
+    sort_order: p.integer().nullable(),
+    created_at: p.integer(),
   },
 });

server/src/db/entities/JourneyPhotos.entity.ts

@@ -1,38 +1,41 @@
-import { Collection, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { Collection, type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { JourneyPhotosRepository } from '../repositories/JourneyPhotos.repository';
 import { JourneyEntryPhotos } from './JourneyEntryPhotos.entity';
 import { Journeys } from './Journeys.entity';
 import { TrekPhotos } from './TrekPhotos.entity';
 
 export class JourneyPhotos {
-  id?: number | null;
+  id!: number & Opt;
   journey!: Ref<Journeys>;
+  journey_id!: number;
   photo!: Ref<TrekPhotos>;
+  photo_id!: number;
   caption?: string | null;
   shared?: number | null = 0;
-  sortOrder?: number | null = 0;
+  sort_order?: number | null = 0;
   provider?: string | null;
-  assetId?: string | null;
-  ownerId?: number | null;
-  createdAt!: number;
-  journeyEntryPhotosCollection = new Collection<JourneyEntryPhotos>(this);
+  asset_id?: string | null;
+  owner_id?: number | null;
+  created_at!: number;
+  journey_entry_photos_collection = new Collection<JourneyEntryPhotos>(this);
 }
 
-export class JourneyPhotosRepository extends EntityRepository<JourneyPhotos> {}
-
 export const JourneyPhotosSchema = defineEntity({
   class: JourneyPhotos,
   repository: () => JourneyPhotosRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    journey: () => p.manyToOne(Journeys).ref().deleteRule('cascade').index('idx_journey_photos_journey'),
-    photo: () => p.manyToOne(TrekPhotos).ref().deleteRule('cascade'),
+    id: p.integer().primary(),
+    journey: () => p.manyToOne(Journeys).ref().deleteRule('cascade').hidden().index('idx_journey_photos_journey'),
+    journey_id: p.integer().persist(false).index('idx_journey_photos_journey'),
+    photo: () => p.manyToOne(TrekPhotos).ref().deleteRule('cascade').hidden(),
+    photo_id: p.integer().persist(false),
     caption: p.text().nullable(),
     shared: p.integer().nullable(),
-    sortOrder: p.integer().nullable(),
+    sort_order: p.integer().nullable(),
     provider: p.text().nullable(),
-    assetId: p.text().nullable(),
-    ownerId: p.integer().nullable(),
-    createdAt: p.integer(),
-    journeyEntryPhotosCollection: () => p.oneToMany(JourneyEntryPhotos).mappedBy('journeyPhoto'),
+    asset_id: p.text().nullable(),
+    owner_id: p.integer().nullable(),
+    created_at: p.integer(),
+    journey_entry_photos_collection: () => p.oneToMany(JourneyEntryPhotos).mappedBy('journeyPhoto').hidden(),
   },
 });

server/src/db/entities/JourneyShareTokens.entity.ts

@@ -1,33 +1,37 @@
-import { type Opt, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { JourneyShareTokensRepository } from '../repositories/JourneyShareTokens.repository';
+import { DbTimestampType } from '../types';
 import { Journeys } from './Journeys.entity';
 import { Users } from './Users.entity';
 
 export class JourneyShareTokens {
-  id?: number | null;
+  id!: number & Opt;
   journey!: Ref<Journeys>;
+  journey_id!: number;
   token!: string;
-  createdBy!: Ref<Users>;
-  shareTimeline?: number | null = 1;
-  shareGallery?: number | null = 1;
-  shareMap?: number | null = 1;
-  createdAt?: Date | null;
-  newestFirst: number & Opt = 0;
+  created_by!: number;
+  share_timeline?: number | null = 1;
+  share_gallery?: number | null = 1;
+  share_map?: number | null = 1;
+  created_at?: string | null;
+  newest_first: number & Opt = 0;
+  createdByRef!: Ref<Users>;
 }
 
-export class JourneyShareTokensRepository extends EntityRepository<JourneyShareTokens> {}
-
 export const JourneyShareTokensSchema = defineEntity({
   class: JourneyShareTokens,
   repository: () => JourneyShareTokensRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    journey: () => p.oneToOne(Journeys).ref().deleteRule('cascade').unique('idx_journey_share_journey'),
+    id: p.integer().primary(),
+    journey: () => p.oneToOne(Journeys).ref().deleteRule('cascade').hidden().unique('idx_journey_share_journey'),
+    journey_id: p.integer().persist(false).unique('idx_journey_share_journey'),
     token: p.text(),
-    createdBy: () => p.manyToOne(Users).ref().name('created_by'),
-    shareTimeline: p.integer().nullable(),
-    shareGallery: p.integer().nullable(),
-    shareMap: p.integer().nullable(),
-    createdAt: p.datetime().nullable().onCreate(() => new Date()),
-    newestFirst: p.integer(),
+    created_by: p.integer().persist(false),
+    share_timeline: p.integer().nullable(),
+    share_gallery: p.integer().nullable(),
+    share_map: p.integer().nullable(),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
+    newest_first: p.integer().default(0),
+    createdByRef: () => p.manyToOne(Users).ref().joinColumn('created_by').hidden(),
   },
 });

server/src/db/entities/JourneyTrips.entity.ts

@@ -1,22 +1,25 @@
-import { PrimaryKeyProp, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { PrimaryKeyProp, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { JourneyTripsRepository } from '../repositories/JourneyTrips.repository';
 import { Journeys } from './Journeys.entity';
 import { Trips } from './Trips.entity';
 
 export class JourneyTrips {
   [PrimaryKeyProp]?: ['journey', 'trip'];
   journey!: Ref<Journeys>;
+  journey_id!: number;
   trip!: Ref<Trips>;
-  addedAt!: number;
+  trip_id!: number;
+  added_at!: number;
 }
 
-export class JourneyTripsRepository extends EntityRepository<JourneyTrips> {}
-
 export const JourneyTripsSchema = defineEntity({
   class: JourneyTrips,
   repository: () => JourneyTripsRepository,
   properties: {
-    journey: () => p.manyToOne(Journeys).primary().ref().index('idx_journey_trips_journey'),
-    trip: () => p.manyToOne(Trips).primary().ref(),
-    addedAt: p.integer(),
+    journey: () => p.manyToOne(Journeys).primary().ref().hidden().index('idx_journey_trips_journey'),
+    journey_id: p.integer().persist(false).index('idx_journey_trips_journey'),
+    trip: () => p.manyToOne(Trips).primary().ref().hidden(),
+    trip_id: p.integer().persist(false),
+    added_at: p.integer(),
   },
 });

server/src/db/entities/Journeys.entity.ts

@@ -1,4 +1,5 @@
-import { Collection, type Opt, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { Collection, type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { JourneysRepository } from '../repositories/Journeys.repository';
 import { JourneyBooks } from './JourneyBooks.entity';
 import { JourneyContributors } from './JourneyContributors.entity';
 import { JourneyEntries } from './JourneyEntries.entity';
@@ -8,51 +9,51 @@ import { JourneyTrips } from './JourneyTrips.entity';
 import { Users } from './Users.entity';
 
 export class Journeys {
-  id?: number | null;
+  id!: number & Opt;
   user!: Ref<Users>;
+  user_id!: number;
   title!: string;
   subtitle?: string | null;
-  coverGradient?: string | null;
+  cover_gradient?: string | null;
   status?: string | null = 'draft';
-  createdAt!: number;
-  updatedAt!: number;
-  coverImage?: string | null;
-  showTripTracks: number & Opt = 0;
-  showVerdict: number & Opt = 1;
-  showMood: number & Opt = 1;
-  showWeather: number & Opt = 1;
-  journeyBooksCollection = new Collection<JourneyBooks>(this);
-  journeyContributorsCollection = new Collection<JourneyContributors>(this);
-  journeyEntriesCollection = new Collection<JourneyEntries>(this);
-  journeyPhotosCollection = new Collection<JourneyPhotos>(this);
-  journeyShareTokens: Ref<JourneyShareTokens> | null = null;
-  journeyTripsCollection = new Collection<JourneyTrips>(this);
+  created_at!: number;
+  updated_at!: number;
+  cover_image?: string | null;
+  show_trip_tracks: number & Opt = 0;
+  show_verdict: number & Opt = 1;
+  show_mood: number & Opt = 1;
+  show_weather: number & Opt = 1;
+  journey_books_collection = new Collection<JourneyBooks>(this);
+  journey_contributors_collection = new Collection<JourneyContributors>(this);
+  journey_entries_collection = new Collection<JourneyEntries>(this);
+  journey_photos_collection = new Collection<JourneyPhotos>(this);
+  journey_share_tokens: Ref<JourneyShareTokens> | null = null;
+  journey_trips_collection = new Collection<JourneyTrips>(this);
 }
 
-export class JourneysRepository extends EntityRepository<Journeys> {}
-
 export const JourneysSchema = defineEntity({
   class: Journeys,
   repository: () => JourneysRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    user: () => p.manyToOne(Users).ref().index('idx_journeys_user'),
+    id: p.integer().primary(),
+    user: () => p.manyToOne(Users).ref().hidden().index('idx_journeys_user'),
+    user_id: p.integer().persist(false).index('idx_journeys_user'),
     title: p.text(),
     subtitle: p.text().nullable(),
-    coverGradient: p.text().nullable(),
+    cover_gradient: p.text().nullable(),
     status: p.text().nullable(),
-    createdAt: p.integer(),
-    updatedAt: p.integer(),
-    coverImage: p.text().nullable(),
-    showTripTracks: p.integer(),
-    showVerdict: p.integer(),
-    showMood: p.integer(),
-    showWeather: p.integer(),
-    journeyBooksCollection: () => p.oneToMany(JourneyBooks).mappedBy('journey'),
-    journeyContributorsCollection: () => p.oneToMany(JourneyContributors).mappedBy('journey'),
-    journeyEntriesCollection: () => p.oneToMany(JourneyEntries).mappedBy('journey'),
-    journeyPhotosCollection: () => p.oneToMany(JourneyPhotos).mappedBy('journey'),
-    journeyShareTokens: () => p.oneToOne(JourneyShareTokens).ref().mappedBy('journey'),
-    journeyTripsCollection: () => p.oneToMany(JourneyTrips).mappedBy('journey'),
+    created_at: p.integer(),
+    updated_at: p.integer(),
+    cover_image: p.text().nullable(),
+    show_trip_tracks: p.integer().default(0),
+    show_verdict: p.integer().default(1),
+    show_mood: p.integer().default(1),
+    show_weather: p.integer().default(1),
+    journey_books_collection: () => p.oneToMany(JourneyBooks).mappedBy('journey').hidden(),
+    journey_contributors_collection: () => p.oneToMany(JourneyContributors).mappedBy('journey').hidden(),
+    journey_entries_collection: () => p.oneToMany(JourneyEntries).mappedBy('journey').hidden(),
+    journey_photos_collection: () => p.oneToMany(JourneyPhotos).mappedBy('journey').hidden(),
+    journey_share_tokens: () => p.oneToOne(JourneyShareTokens).ref().mappedBy('journey').hidden(),
+    journey_trips_collection: () => p.oneToMany(JourneyTrips).mappedBy('journey').hidden(),
   },
 });

server/src/db/entities/McpTokens.entity.ts

@@ -1,34 +1,36 @@
-import { type Opt, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { McpTokensRepository } from '../repositories/McpTokens.repository';
+import { DbTimestampType } from '../types';
 import { Users } from './Users.entity';
 
 export class McpTokens {
-  id?: number | null;
+  id!: number & Opt;
   user!: Ref<Users>;
+  user_id!: number;
   name!: string;
-  tokenHash!: string;
-  tokenPrefix!: string;
-  createdAt?: Date | null;
-  lastUsedAt?: Date | null;
+  token_hash!: string;
+  token_prefix!: string;
+  created_at?: string | null;
+  last_used_at?: string | null;
   kind: string & Opt = 'mcp';
-  scopeMode: string & Opt = 'all';
-  apiScopes?: string | null;
+  scope_mode: string & Opt = 'all';
+  api_scopes?: string | null;
 }
 
-export class McpTokensRepository extends EntityRepository<McpTokens> {}
-
 export const McpTokensSchema = defineEntity({
   class: McpTokens,
   repository: () => McpTokensRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    user: () => p.manyToOne(Users).ref().deleteRule('cascade'),
+    id: p.integer().primary(),
+    user: () => p.manyToOne(Users).ref().deleteRule('cascade').hidden(),
+    user_id: p.integer().persist(false),
     name: p.text(),
-    tokenHash: p.text().unique('idx_mcp_tokens_hash'),
-    tokenPrefix: p.text(),
-    createdAt: p.datetime().nullable().onCreate(() => new Date()),
-    lastUsedAt: p.datetime().nullable(),
-    kind: p.text(),
-    scopeMode: p.text(),
-    apiScopes: p.text().nullable(),
+    token_hash: p.text().unique('idx_mcp_tokens_hash'),
+    token_prefix: p.text(),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
+    last_used_at: p.type(DbTimestampType).nullable(),
+    kind: p.text().default('mcp'),
+    scope_mode: p.text().default('all'),
+    api_scopes: p.text().nullable(),
   },
 });

server/src/db/entities/Migrations.entity.ts

@@ -1,4 +1,5 @@
-import { defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { defineEntity, p } from '@mikro-orm/core';
+import { MigrationsRepository } from '../repositories/Migrations.repository';
 
 export class Migrations {
   id!: number;
@@ -6,8 +7,6 @@ export class Migrations {
   name!: string;
 }
 
-export class MigrationsRepository extends EntityRepository<Migrations> {}
-
 export const MigrationsSchema = defineEntity({
   class: Migrations,
   repository: () => MigrationsRepository,

server/src/db/entities/NotificationChannelPreferences.entity.ts

@@ -1,23 +1,24 @@
-import { type Opt, PrimaryKeyProp, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, PrimaryKeyProp, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { NotificationChannelPreferencesRepository } from '../repositories/NotificationChannelPreferences.repository';
 import { Users } from './Users.entity';
 
 export class NotificationChannelPreferences {
-  [PrimaryKeyProp]?: ['user', 'eventType', 'channel'];
+  [PrimaryKeyProp]?: ['user', 'event_type', 'channel'];
   user!: Ref<Users>;
-  eventType!: string;
+  user_id!: number;
+  event_type!: string;
   channel!: string;
   enabled: number & Opt = 1;
 }
 
-export class NotificationChannelPreferencesRepository extends EntityRepository<NotificationChannelPreferences> {}
-
 export const NotificationChannelPreferencesSchema = defineEntity({
   class: NotificationChannelPreferences,
   repository: () => NotificationChannelPreferencesRepository,
   properties: {
-    user: () => p.manyToOne(Users).primary().ref().deleteRule('cascade').index('idx_ncp_user'),
-    eventType: p.text().primary(),
+    user: () => p.manyToOne(Users).primary().ref().deleteRule('cascade').hidden().index('idx_ncp_user'),
+    user_id: p.integer().persist(false).index('idx_ncp_user'),
+    event_type: p.text().primary(),
     channel: p.text().primary(),
-    enabled: p.integer(),
+    enabled: p.integer().default(1),
   },
 });

server/src/db/entities/Notifications.entity.ts

@@ -1,30 +1,32 @@
-import { type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { NotificationsRepository } from '../repositories/Notifications.repository';
+import { DbTimestampType } from '../types';
 import { Users } from './Users.entity';
 
 export class Notifications {
-  id?: number | null;
+  id!: number & Opt;
   type!: string;
   scope!: string;
   target!: number;
   sender?: Ref<Users> | null;
+  sender_id?: number | null;
   recipient!: Ref<Users>;
-  titleKey!: string;
-  titleParams?: string | null = '{}';
-  textKey!: string;
-  textParams?: string | null = '{}';
-  positiveTextKey?: string | null;
-  negativeTextKey?: string | null;
-  positiveCallback?: string | null;
-  negativeCallback?: string | null;
+  recipient_id!: number;
+  title_key!: string;
+  title_params?: string | null = '{}';
+  text_key!: string;
+  text_params?: string | null = '{}';
+  positive_text_key?: string | null;
+  negative_text_key?: string | null;
+  positive_callback?: string | null;
+  negative_callback?: string | null;
   response?: string | null;
-  navigateTextKey?: string | null;
-  navigateTarget?: string | null;
-  isRead?: number | null = 0;
-  createdAt?: Date | null;
+  navigate_text_key?: string | null;
+  navigate_target?: string | null;
+  is_read?: number | null = 0;
+  created_at?: string | null;
 }
 
-export class NotificationsRepository extends EntityRepository<Notifications> {}
-
 export const NotificationsSchema = defineEntity({
   class: Notifications,
   repository: () => NotificationsRepository,
@@ -32,32 +34,34 @@ export const NotificationsSchema = defineEntity({
     { name: 'idx_notifications_target_scope', properties: ['target', 'scope'] },
     {
       name: 'idx_notifications_recipient_created',
-      properties: ['recipient', 'createdAt'],
+      properties: ['recipient_id', 'created_at'],
     },
     {
       name: 'idx_notifications_recipient',
-      properties: ['recipient', 'isRead', 'createdAt'],
+      properties: ['recipient_id', 'is_read', 'created_at'],
     },
   ],
   properties: {
-    id: p.integer().primary().autoincrement(),
+    id: p.integer().primary(),
     type: p.text(),
     scope: p.text(),
     target: p.integer(),
-    sender: () => p.manyToOne(Users).ref().nullable(),
-    recipient: () => p.manyToOne(Users).ref().deleteRule('cascade'),
-    titleKey: p.text(),
-    titleParams: p.text().nullable(),
-    textKey: p.text(),
-    textParams: p.text().nullable(),
-    positiveTextKey: p.text().nullable(),
-    negativeTextKey: p.text().nullable(),
-    positiveCallback: p.text().nullable(),
-    negativeCallback: p.text().nullable(),
+    sender: () => p.manyToOne(Users).ref().nullable().hidden(),
+    sender_id: p.integer().nullable().persist(false),
+    recipient: () => p.manyToOne(Users).ref().deleteRule('cascade').hidden(),
+    recipient_id: p.integer().persist(false),
+    title_key: p.text(),
+    title_params: p.text().nullable(),
+    text_key: p.text(),
+    text_params: p.text().nullable(),
+    positive_text_key: p.text().nullable(),
+    negative_text_key: p.text().nullable(),
+    positive_callback: p.text().nullable(),
+    negative_callback: p.text().nullable(),
     response: p.text().nullable(),
-    navigateTextKey: p.text().nullable(),
-    navigateTarget: p.text().nullable(),
-    isRead: p.integer().nullable(),
-    createdAt: p.datetime().nullable().onCreate(() => new Date()),
+    navigate_text_key: p.text().nullable(),
+    navigate_target: p.text().nullable(),
+    is_read: p.integer().nullable(),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
   },
 });

server/src/db/entities/OauthClients.entity.ts

@@ -1,4 +1,6 @@
-import { Collection, type Opt, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { Collection, type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { OauthClientsRepository } from '../repositories/OauthClients.repository';
+import { DbTimestampType } from '../types';
 import { OauthConsents } from './OauthConsents.entity';
 import { OauthTokens } from './OauthTokens.entity';
 import { Users } from './Users.entity';
@@ -6,37 +8,37 @@ import { Users } from './Users.entity';
 export class OauthClients {
   id?: string | null;
   user?: Ref<Users> | null;
+  user_id?: number | null;
   name!: string;
-  clientId!: string;
-  clientSecretHash!: string;
-  redirectUris: string & Opt = '[]';
-  allowedScopes: string & Opt = '[]';
-  createdAt?: Date | null;
-  isPublic: number & Opt = 0;
-  createdVia: string & Opt = 'settings_ui';
-  allowsClientCredentials: number & Opt = 0;
-  oauthConsentsCollection = new Collection<OauthConsents>(this);
-  oauthTokensCollection = new Collection<OauthTokens>(this);
+  client_id!: string;
+  client_secret_hash!: string;
+  redirect_uris: string & Opt = '[]';
+  allowed_scopes: string & Opt = '[]';
+  created_at?: string | null;
+  is_public: number & Opt = 0;
+  created_via: string & Opt = 'settings_ui';
+  allows_client_credentials: number & Opt = 0;
+  oauth_consents_collection = new Collection<OauthConsents>(this);
+  oauth_tokens_collection = new Collection<OauthTokens>(this);
 }
 
-export class OauthClientsRepository extends EntityRepository<OauthClients> {}
-
 export const OauthClientsSchema = defineEntity({
   class: OauthClients,
   repository: () => OauthClientsRepository,
   properties: {
     id: p.text().primary().nullable(),
-    user: () => p.manyToOne(Users).ref().deleteRule('cascade').nullable().index('idx_oauth_clients_user'),
+    user: () => p.manyToOne(Users).ref().deleteRule('cascade').nullable().hidden().index('idx_oauth_clients_user'),
+    user_id: p.integer().nullable().persist(false).index('idx_oauth_clients_user'),
     name: p.text(),
-    clientId: p.text().unique('idx_oauth_clients_client_id'),
-    clientSecretHash: p.text(),
-    redirectUris: p.text(),
-    allowedScopes: p.text(),
-    createdAt: p.datetime().nullable().onCreate(() => new Date()),
-    isPublic: p.integer(),
-    createdVia: p.text(),
-    allowsClientCredentials: p.integer(),
-    oauthConsentsCollection: () => p.oneToMany(OauthConsents).mappedBy('client'),
-    oauthTokensCollection: () => p.oneToMany(OauthTokens).mappedBy('client'),
+    client_id: p.text().unique('idx_oauth_clients_client_id'),
+    client_secret_hash: p.text(),
+    redirect_uris: p.text().default('[]'),
+    allowed_scopes: p.text().default('[]'),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
+    is_public: p.integer().default(0),
+    created_via: p.text().default('settings_ui'),
+    allows_client_credentials: p.integer().default(0),
+    oauth_consents_collection: () => p.oneToMany(OauthConsents).mappedBy('client').hidden(),
+    oauth_tokens_collection: () => p.oneToMany(OauthTokens).mappedBy('client').hidden(),
   },
 });

server/src/db/entities/OauthConsents.entity.ts

@@ -1,25 +1,29 @@
-import { type Opt, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { OauthConsentsRepository } from '../repositories/OauthConsents.repository';
+import { DbTimestampType } from '../types';
 import { OauthClients } from './OauthClients.entity';
 import { Users } from './Users.entity';
 
 export class OauthConsents {
-  id?: number | null;
+  id!: number & Opt;
   client!: Ref<OauthClients>;
+  client_id!: string;
   user!: Ref<Users>;
+  user_id!: number;
   scopes: string & Opt = '[]';
-  updatedAt?: Date | null;
+  updated_at?: string | null;
 }
 
-export class OauthConsentsRepository extends EntityRepository<OauthConsents> {}
-
 export const OauthConsentsSchema = defineEntity({
   class: OauthConsents,
   repository: () => OauthConsentsRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    client: () => p.manyToOne(OauthClients).ref().name('client_id').deleteRule('cascade'),
-    user: () => p.manyToOne(Users).ref().deleteRule('cascade'),
-    scopes: p.text(),
-    updatedAt: p.datetime().nullable().onCreate(() => new Date()),
+    id: p.integer().primary(),
+    client: () => p.manyToOne(OauthClients).ref().name('client_id').deleteRule('cascade').hidden(),
+    client_id: p.text().persist(false),
+    user: () => p.manyToOne(Users).ref().deleteRule('cascade').hidden(),
+    user_id: p.integer().persist(false),
+    scopes: p.text().default('[]'),
+    updated_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
   },
 });

server/src/db/entities/OauthTokens.entity.ts

@@ -1,41 +1,47 @@
-import { Collection, type Opt, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { Collection, type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { OauthTokensRepository } from '../repositories/OauthTokens.repository';
+import { DbTimestampType } from '../types';
 import { OauthClients } from './OauthClients.entity';
 import { Users } from './Users.entity';
 
 export class OauthTokens {
-  id?: number | null;
+  id!: number & Opt;
   client!: Ref<OauthClients>;
+  client_id!: string;
   user!: Ref<Users>;
-  accessTokenHash!: string;
-  refreshTokenHash!: string;
+  user_id!: number;
+  access_token_hash!: string;
+  refresh_token_hash!: string;
   scopes: string & Opt = '[]';
-  accessTokenExpiresAt!: Date;
-  refreshTokenExpiresAt!: Date;
-  revokedAt?: Date | null;
-  createdAt?: Date | null;
+  access_token_expires_at!: string;
+  refresh_token_expires_at!: string;
+  revoked_at?: string | null;
+  created_at?: string | null;
   parentToken?: Ref<OauthTokens> | null;
+  parent_token_id?: number | null;
   audience?: string | null;
-  oauthTokensCollection = new Collection<OauthTokens>(this);
+  oauth_tokens_collection = new Collection<OauthTokens>(this);
 }
 
-export class OauthTokensRepository extends EntityRepository<OauthTokens> {}
-
 export const OauthTokensSchema = defineEntity({
   class: OauthTokens,
   repository: () => OauthTokensRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    client: () => p.manyToOne(OauthClients).ref().name('client_id').deleteRule('cascade'),
-    user: () => p.manyToOne(Users).ref().deleteRule('cascade').index('idx_oauth_tokens_user'),
-    accessTokenHash: p.text().unique('idx_oauth_tokens_access'),
-    refreshTokenHash: p.text().unique('idx_oauth_tokens_refresh'),
-    scopes: p.text(),
-    accessTokenExpiresAt: p.datetime(),
-    refreshTokenExpiresAt: p.datetime(),
-    revokedAt: p.datetime().nullable(),
-    createdAt: p.datetime().nullable().onCreate(() => new Date()),
-    parentToken: () => p.manyToOne(OauthTokens).ref().nullable().index('idx_oauth_tokens_parent'),
+    id: p.integer().primary(),
+    client: () => p.manyToOne(OauthClients).ref().name('client_id').deleteRule('cascade').hidden(),
+    client_id: p.text().persist(false),
+    user: () => p.manyToOne(Users).ref().deleteRule('cascade').hidden().index('idx_oauth_tokens_user'),
+    user_id: p.integer().persist(false).index('idx_oauth_tokens_user'),
+    access_token_hash: p.text().unique('idx_oauth_tokens_access'),
+    refresh_token_hash: p.text().unique('idx_oauth_tokens_refresh'),
+    scopes: p.text().default('[]'),
+    access_token_expires_at: p.type(DbTimestampType),
+    refresh_token_expires_at: p.type(DbTimestampType),
+    revoked_at: p.type(DbTimestampType).nullable(),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
+    parentToken: () => p.manyToOne(OauthTokens).ref().nullable().hidden().index('idx_oauth_tokens_parent'),
+    parent_token_id: p.integer().nullable().persist(false).index('idx_oauth_tokens_parent'),
     audience: p.text().nullable(),
-    oauthTokensCollection: () => p.oneToMany(OauthTokens).mappedBy('parentToken'),
+    oauth_tokens_collection: () => p.oneToMany(OauthTokens).mappedBy('parentToken').hidden(),
   },
 });

server/src/db/entities/PackingBags.entity.ts

@@ -1,36 +1,40 @@
-import { Collection, type Opt, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { Collection, type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { PackingBagsRepository } from '../repositories/PackingBags.repository';
+import { DbTimestampType } from '../types';
 import { PackingItems } from './PackingItems.entity';
 import { Trips } from './Trips.entity';
 import { Users } from './Users.entity';
 
 export class PackingBags {
-  id?: number | null;
+  id!: number & Opt;
   trip!: Ref<Trips>;
+  trip_id!: number;
   name!: string;
   color: string & Opt = '#6366f1';
-  weightLimitGrams?: number | null;
-  sortOrder?: number | null = 0;
-  createdAt?: Date | null;
+  weight_limit_grams?: number | null;
+  sort_order?: number | null = 0;
+  created_at?: string | null;
   user?: Ref<Users> | null;
-  packingBagMembers = new Collection<Users>(this);
-  packingItemsCollection = new Collection<PackingItems>(this);
+  user_id?: number | null = NaN;
+  packing_bag_members = new Collection<Users>(this);
+  packing_items_collection = new Collection<PackingItems>(this);
 }
 
-export class PackingBagsRepository extends EntityRepository<PackingBags> {}
-
 export const PackingBagsSchema = defineEntity({
   class: PackingBags,
   repository: () => PackingBagsRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    trip: () => p.manyToOne(Trips).ref().deleteRule('cascade'),
+    id: p.integer().primary(),
+    trip: () => p.manyToOne(Trips).ref().deleteRule('cascade').hidden(),
+    trip_id: p.integer().persist(false),
     name: p.text(),
-    color: p.text(),
-    weightLimitGrams: p.integer().nullable(),
-    sortOrder: p.integer().nullable(),
-    createdAt: p.datetime().nullable().onCreate(() => new Date()),
-    user: () => p.manyToOne(Users).ref().nullable(),
-    packingBagMembers: () => p.manyToMany(Users).pivotTable('packing_bag_members').joinColumn('bag_id').inverseJoinColumn('user_id'),
-    packingItemsCollection: () => p.oneToMany(PackingItems).mappedBy('bag'),
+    color: p.text().default('#6366f1'),
+    weight_limit_grams: p.integer().nullable(),
+    sort_order: p.integer().nullable(),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
+    user: () => p.manyToOne(Users).ref().nullable().hidden().defaultRaw(`NULL`),
+    user_id: p.integer().nullable().persist(false).defaultRaw(`NULL`),
+    packing_bag_members: () => p.manyToMany(Users).pivotTable('packing_bag_members').joinColumn('bag_id').inverseJoinColumn('user_id').hidden(),
+    packing_items_collection: () => p.oneToMany(PackingItems).mappedBy('bag').hidden(),
   },
 });

server/src/db/entities/PackingCategoryAssignees.entity.ts

@@ -1,23 +1,26 @@
-import { type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { PackingCategoryAssigneesRepository } from '../repositories/PackingCategoryAssignees.repository';
 import { Trips } from './Trips.entity';
 import { Users } from './Users.entity';
 
 export class PackingCategoryAssignees {
-  id?: number | null;
+  id!: number & Opt;
   trip!: Ref<Trips>;
-  categoryName!: string;
+  trip_id!: number;
+  category_name!: string;
   user!: Ref<Users>;
+  user_id!: number;
 }
 
-export class PackingCategoryAssigneesRepository extends EntityRepository<PackingCategoryAssignees> {}
-
 export const PackingCategoryAssigneesSchema = defineEntity({
   class: PackingCategoryAssignees,
   repository: () => PackingCategoryAssigneesRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    trip: () => p.manyToOne(Trips).ref().deleteRule('cascade'),
-    categoryName: p.text(),
-    user: () => p.manyToOne(Users).ref().deleteRule('cascade'),
+    id: p.integer().primary(),
+    trip: () => p.manyToOne(Trips).ref().deleteRule('cascade').hidden(),
+    trip_id: p.integer().persist(false),
+    category_name: p.text(),
+    user: () => p.manyToOne(Users).ref().deleteRule('cascade').hidden(),
+    user_id: p.integer().persist(false),
   },
 });

server/src/db/entities/PackingItemContributors.entity.ts

@@ -1,24 +1,28 @@
-import { type Opt, PrimaryKeyProp, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, PrimaryKeyProp, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { PackingItemContributorsRepository } from '../repositories/PackingItemContributors.repository';
+import { DbTimestampType } from '../types';
 import { PackingItems } from './PackingItems.entity';
 import { Users } from './Users.entity';
 
 export class PackingItemContributors {
   [PrimaryKeyProp]?: ['item', 'user'];
   item!: Ref<PackingItems>;
+  item_id!: number;
   user!: Ref<Users>;
+  user_id!: number;
   status: string & Opt = 'accepted';
-  createdAt?: Date | null;
+  created_at?: string | null;
 }
 
-export class PackingItemContributorsRepository extends EntityRepository<PackingItemContributors> {}
-
 export const PackingItemContributorsSchema = defineEntity({
   class: PackingItemContributors,
   repository: () => PackingItemContributorsRepository,
   properties: {
-    item: () => p.manyToOne(PackingItems).primary().ref(),
-    user: () => p.manyToOne(Users).primary().ref(),
-    status: p.text(),
-    createdAt: p.datetime().nullable().onCreate(() => new Date()),
+    item: () => p.manyToOne(PackingItems).primary().ref().hidden(),
+    item_id: p.integer().persist(false),
+    user: () => p.manyToOne(Users).primary().ref().hidden(),
+    user_id: p.integer().persist(false),
+    status: p.text().default('accepted'),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
   },
 });

server/src/db/entities/PackingItems.entity.ts

@@ -1,49 +1,55 @@
-import { Collection, type Opt, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { Collection, type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { PackingItemsRepository } from '../repositories/PackingItems.repository';
+import { DbTimestampType } from '../types';
 import { PackingBags } from './PackingBags.entity';
 import { PackingItemContributors } from './PackingItemContributors.entity';
 import { Trips } from './Trips.entity';
 import { Users } from './Users.entity';
 
 export class PackingItems {
-  id?: number | null;
+  id!: number & Opt;
   trip!: Ref<Trips>;
+  trip_id!: number;
   name!: string;
   checked?: number | null = 0;
   category?: string | null;
-  sortOrder?: number | null = 0;
-  createdAt?: Date | null;
-  weightGrams?: number | null;
+  sort_order?: number | null = 0;
+  created_at?: string | null;
+  weight_grams?: number | null;
   bag?: Ref<PackingBags> | null;
+  bag_id?: number | null;
   quantity: number & Opt = 1;
-  updatedAt?: Date | null;
-  isPrivate: number & Opt = 0;
+  updated_at?: string | null;
+  is_private: number & Opt = 0;
   owner?: Ref<Users> | null;
-  packingItemContributors = new Collection<Users>(this);
-  packingItemRecipients = new Collection<Users>(this);
-  packingItemContributorsCollection = new Collection<PackingItemContributors>(this);
+  owner_id?: number | null;
+  packing_item_contributors = new Collection<Users>(this);
+  packing_item_recipients = new Collection<Users>(this);
+  packing_item_contributors_collection = new Collection<PackingItemContributors>(this);
 }
 
-export class PackingItemsRepository extends EntityRepository<PackingItems> {}
-
 export const PackingItemsSchema = defineEntity({
   class: PackingItems,
   repository: () => PackingItemsRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    trip: () => p.manyToOne(Trips).ref().deleteRule('cascade').index('idx_packing_items_trip_id'),
+    id: p.integer().primary(),
+    trip: () => p.manyToOne(Trips).ref().deleteRule('cascade').hidden().index('idx_packing_items_trip_id'),
+    trip_id: p.integer().persist(false).index('idx_packing_items_trip_id'),
     name: p.text(),
     checked: p.integer().nullable(),
     category: p.text().nullable(),
-    sortOrder: p.integer().nullable(),
-    createdAt: p.datetime().nullable().onCreate(() => new Date()),
-    weightGrams: p.integer().nullable(),
-    bag: () => p.manyToOne(PackingBags).ref().nullable(),
-    quantity: p.integer(),
-    updatedAt: p.datetime().nullable(),
-    isPrivate: p.integer(),
-    owner: () => p.manyToOne(Users).ref().nullable(),
-    packingItemContributors: () => p.manyToMany(Users).pivotTable('packing_item_contributors').pivotEntity(() => PackingItemContributors).joinColumn('item_id').inverseJoinColumn('user_id'),
-    packingItemRecipients: () => p.manyToMany(Users).pivotTable('packing_item_recipients').joinColumn('item_id').inverseJoinColumn('user_id'),
-    packingItemContributorsCollection: () => p.oneToMany(PackingItemContributors).mappedBy('item'),
+    sort_order: p.integer().nullable(),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
+    weight_grams: p.integer().nullable(),
+    bag: () => p.manyToOne(PackingBags).ref().nullable().hidden(),
+    bag_id: p.integer().nullable().persist(false),
+    quantity: p.integer().default(1),
+    updated_at: p.type(DbTimestampType).nullable(),
+    is_private: p.integer().default(0),
+    owner: () => p.manyToOne(Users).ref().nullable().hidden(),
+    owner_id: p.integer().nullable().persist(false),
+    packing_item_contributors: () => p.manyToMany(Users).pivotTable('packing_item_contributors').pivotEntity(() => PackingItemContributors).joinColumn('item_id').inverseJoinColumn('user_id').hidden(),
+    packing_item_recipients: () => p.manyToMany(Users).pivotTable('packing_item_recipients').joinColumn('item_id').inverseJoinColumn('user_id').hidden(),
+    packing_item_contributors_collection: () => p.oneToMany(PackingItemContributors).mappedBy('item').hidden(),
   },
 });

server/src/db/entities/PackingTemplateCategories.entity.ts

@@ -1,25 +1,26 @@
-import { Collection, type Opt, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { Collection, type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { PackingTemplateCategoriesRepository } from '../repositories/PackingTemplateCategories.repository';
 import { PackingTemplateItems } from './PackingTemplateItems.entity';
 import { PackingTemplates } from './PackingTemplates.entity';
 
 export class PackingTemplateCategories {
-  id?: number | null;
+  id!: number & Opt;
   template!: Ref<PackingTemplates>;
+  template_id!: number;
   name!: string;
-  sortOrder: number & Opt = 0;
-  packingTemplateItemsCollection = new Collection<PackingTemplateItems>(this);
+  sort_order: number & Opt = 0;
+  packing_template_items_collection = new Collection<PackingTemplateItems>(this);
 }
 
-export class PackingTemplateCategoriesRepository extends EntityRepository<PackingTemplateCategories> {}
-
 export const PackingTemplateCategoriesSchema = defineEntity({
   class: PackingTemplateCategories,
   repository: () => PackingTemplateCategoriesRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    template: () => p.manyToOne(PackingTemplates).ref().deleteRule('cascade'),
+    id: p.integer().primary(),
+    template: () => p.manyToOne(PackingTemplates).ref().deleteRule('cascade').hidden(),
+    template_id: p.integer().persist(false),
     name: p.text(),
-    sortOrder: p.integer(),
-    packingTemplateItemsCollection: () => p.oneToMany(PackingTemplateItems).mappedBy('category'),
+    sort_order: p.integer().default(0),
+    packing_template_items_collection: () => p.oneToMany(PackingTemplateItems).mappedBy('category').hidden(),
   },
 });

server/src/db/entities/PackingTemplateItems.entity.ts

@@ -1,22 +1,23 @@
-import { type Opt, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { PackingTemplateItemsRepository } from '../repositories/PackingTemplateItems.repository';
 import { PackingTemplateCategories } from './PackingTemplateCategories.entity';
 
 export class PackingTemplateItems {
-  id?: number | null;
+  id!: number & Opt;
   category!: Ref<PackingTemplateCategories>;
+  category_id!: number;
   name!: string;
-  sortOrder: number & Opt = 0;
+  sort_order: number & Opt = 0;
 }
 
-export class PackingTemplateItemsRepository extends EntityRepository<PackingTemplateItems> {}
-
 export const PackingTemplateItemsSchema = defineEntity({
   class: PackingTemplateItems,
   repository: () => PackingTemplateItemsRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    category: () => p.manyToOne(PackingTemplateCategories).ref().deleteRule('cascade'),
+    id: p.integer().primary(),
+    category: () => p.manyToOne(PackingTemplateCategories).ref().deleteRule('cascade').hidden(),
+    category_id: p.integer().persist(false),
     name: p.text(),
-    sortOrder: p.integer(),
+    sort_order: p.integer().default(0),
   },
 });

server/src/db/entities/PackingTemplates.entity.ts

@@ -1,25 +1,27 @@
-import { Collection, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { Collection, type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { PackingTemplatesRepository } from '../repositories/PackingTemplates.repository';
+import { DbTimestampType } from '../types';
 import { PackingTemplateCategories } from './PackingTemplateCategories.entity';
 import { Users } from './Users.entity';
 
 export class PackingTemplates {
-  id?: number | null;
+  id!: number & Opt;
   name!: string;
-  createdBy!: Ref<Users>;
-  createdAt?: Date | null;
-  packingTemplateCategoriesCollection = new Collection<PackingTemplateCategories>(this);
+  created_by!: number;
+  created_at?: string | null;
+  createdByRef!: Ref<Users>;
+  packing_template_categories_collection = new Collection<PackingTemplateCategories>(this);
 }
 
-export class PackingTemplatesRepository extends EntityRepository<PackingTemplates> {}
-
 export const PackingTemplatesSchema = defineEntity({
   class: PackingTemplates,
   repository: () => PackingTemplatesRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
+    id: p.integer().primary(),
     name: p.text(),
-    createdBy: () => p.manyToOne(Users).ref().name('created_by').deleteRule('cascade'),
-    createdAt: p.datetime().nullable().onCreate(() => new Date()),
-    packingTemplateCategoriesCollection: () => p.oneToMany(PackingTemplateCategories).mappedBy('template'),
+    created_by: p.integer().persist(false),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
+    createdByRef: () => p.manyToOne(Users).ref().joinColumn('created_by').deleteRule('cascade').hidden(),
+    packing_template_categories_collection: () => p.oneToMany(PackingTemplateCategories).mappedBy('template').hidden(),
   },
 });

server/src/db/entities/PasswordResetTokens.entity.ts

@@ -1,28 +1,30 @@
-import { type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { PasswordResetTokensRepository } from '../repositories/PasswordResetTokens.repository';
+import { DbTimestampType } from '../types';
 import { Users } from './Users.entity';
 
 export class PasswordResetTokens {
-  id?: number | null;
+  id!: number & Opt;
   user!: Ref<Users>;
-  tokenHash!: string;
-  expiresAt!: Date;
-  consumedAt?: Date | null;
-  createdAt?: Date | null;
-  createdIp?: string | null;
+  user_id!: number;
+  token_hash!: string;
+  expires_at!: string;
+  consumed_at?: string | null;
+  created_at?: string | null;
+  created_ip?: string | null;
 }
 
-export class PasswordResetTokensRepository extends EntityRepository<PasswordResetTokens> {}
-
 export const PasswordResetTokensSchema = defineEntity({
   class: PasswordResetTokens,
   repository: () => PasswordResetTokensRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    user: () => p.manyToOne(Users).ref().deleteRule('cascade').index('idx_prt_user'),
-    tokenHash: p.text().index('idx_prt_hash'),
-    expiresAt: p.datetime(),
-    consumedAt: p.datetime().nullable(),
-    createdAt: p.datetime().nullable().onCreate(() => new Date()),
-    createdIp: p.text().nullable(),
+    id: p.integer().primary(),
+    user: () => p.manyToOne(Users).ref().deleteRule('cascade').hidden().index('idx_prt_user'),
+    user_id: p.integer().persist(false).index('idx_prt_user'),
+    token_hash: p.text().index('idx_prt_hash'),
+    expires_at: p.type(DbTimestampType),
+    consumed_at: p.type(DbTimestampType).nullable(),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
+    created_ip: p.text().nullable(),
   },
 });

server/src/db/entities/PhotoProviderFields.entity.ts

@@ -1,38 +1,39 @@
-import { type Opt, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { PhotoProviderFieldsRepository } from '../repositories/PhotoProviderFields.repository';
 import { PhotoProviders } from './PhotoProviders.entity';
 
 export class PhotoProviderFields {
-  id?: number | null;
+  id!: number & Opt;
   provider!: Ref<PhotoProviders>;
-  fieldKey!: string;
+  provider_id!: string;
+  field_key!: string;
   label!: string;
-  inputType: string & Opt = 'text';
+  input_type: string & Opt = 'text';
   placeholder?: string | null;
   hint?: string | null;
   required?: number | null = 0;
   secret?: number | null = 0;
-  settingsKey?: string | null;
-  payloadKey?: string | null;
-  sortOrder?: number | null = 0;
+  settings_key?: string | null;
+  payload_key?: string | null;
+  sort_order?: number | null = 0;
 }
 
-export class PhotoProviderFieldsRepository extends EntityRepository<PhotoProviderFields> {}
-
 export const PhotoProviderFieldsSchema = defineEntity({
   class: PhotoProviderFields,
   repository: () => PhotoProviderFieldsRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    provider: () => p.manyToOne(PhotoProviders).ref().deleteRule('cascade'),
-    fieldKey: p.text(),
+    id: p.integer().primary(),
+    provider: () => p.manyToOne(PhotoProviders).ref().deleteRule('cascade').hidden(),
+    provider_id: p.text().persist(false),
+    field_key: p.text(),
     label: p.text(),
-    inputType: p.text(),
+    input_type: p.text().default('text'),
     placeholder: p.text().nullable(),
     hint: p.text().nullable(),
     required: p.integer().nullable(),
     secret: p.integer().nullable(),
-    settingsKey: p.text().nullable(),
-    payloadKey: p.text().nullable(),
-    sortOrder: p.integer().nullable(),
+    settings_key: p.text().nullable(),
+    payload_key: p.text().nullable(),
+    sort_order: p.integer().nullable(),
   },
 });

server/src/db/entities/PhotoProviders.entity.ts

@@ -1,4 +1,5 @@
-import { Collection, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { Collection, defineEntity, p } from '@mikro-orm/core';
+import { PhotoProvidersRepository } from '../repositories/PhotoProviders.repository';
 import { PhotoProviderFields } from './PhotoProviderFields.entity';
 
 export class PhotoProviders {
@@ -7,12 +8,10 @@ export class PhotoProviders {
   description?: string | null;
   icon?: string | null = 'Image';
   enabled?: number | null = 0;
-  sortOrder?: number | null = 0;
-  photoProviderFieldsCollection = new Collection<PhotoProviderFields>(this);
+  sort_order?: number | null = 0;
+  photo_provider_fields_collection = new Collection<PhotoProviderFields>(this);
 }
 
-export class PhotoProvidersRepository extends EntityRepository<PhotoProviders> {}
-
 export const PhotoProvidersSchema = defineEntity({
   class: PhotoProviders,
   repository: () => PhotoProvidersRepository,
@@ -22,7 +21,7 @@ export const PhotoProvidersSchema = defineEntity({
     description: p.text().nullable(),
     icon: p.text().nullable(),
     enabled: p.integer().nullable(),
-    sortOrder: p.integer().nullable(),
-    photoProviderFieldsCollection: () => p.oneToMany(PhotoProviderFields).mappedBy('provider'),
+    sort_order: p.integer().nullable(),
+    photo_provider_fields_collection: () => p.oneToMany(PhotoProviderFields).mappedBy('provider').hidden(),
   },
 });

server/src/db/entities/Photos.entity.ts

@@ -1,38 +1,44 @@
-import { type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { PhotosRepository } from '../repositories/Photos.repository';
+import { DbTimestampType } from '../types';
 import { Days } from './Days.entity';
 import { Places } from './Places.entity';
 import { Trips } from './Trips.entity';
 
 export class Photos {
-  id?: number | null;
+  id!: number & Opt;
   trip!: Ref<Trips>;
+  trip_id!: number;
   day?: Ref<Days> | null;
+  day_id?: number | null;
   place?: Ref<Places> | null;
+  place_id?: number | null;
   filename!: string;
-  originalName!: string;
-  fileSize?: number | null;
-  mimeType?: string | null;
+  original_name!: string;
+  file_size?: number | null;
+  mime_type?: string | null;
   caption?: string | null;
-  takenAt?: string | null;
-  createdAt?: Date | null;
+  taken_at?: string | null;
+  created_at?: string | null;
 }
 
-export class PhotosRepository extends EntityRepository<Photos> {}
-
 export const PhotosSchema = defineEntity({
   class: Photos,
   repository: () => PhotosRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    trip: () => p.manyToOne(Trips).ref().deleteRule('cascade').index('idx_photos_trip_id'),
-    day: () => p.manyToOne(Days).ref().nullable().index('idx_photos_day_id'),
-    place: () => p.manyToOne(Places).ref().nullable().index('idx_photos_place_id'),
+    id: p.integer().primary(),
+    trip: () => p.manyToOne(Trips).ref().deleteRule('cascade').hidden().index('idx_photos_trip_id'),
+    trip_id: p.integer().persist(false).index('idx_photos_trip_id'),
+    day: () => p.manyToOne(Days).ref().nullable().hidden().index('idx_photos_day_id'),
+    day_id: p.integer().nullable().persist(false).index('idx_photos_day_id'),
+    place: () => p.manyToOne(Places).ref().nullable().hidden().index('idx_photos_place_id'),
+    place_id: p.integer().nullable().persist(false).index('idx_photos_place_id'),
     filename: p.text(),
-    originalName: p.text(),
-    fileSize: p.integer().nullable(),
-    mimeType: p.text().nullable(),
+    original_name: p.text(),
+    file_size: p.integer().nullable(),
+    mime_type: p.text().nullable(),
     caption: p.text().nullable(),
-    takenAt: p.text().nullable(),
-    createdAt: p.datetime().nullable().onCreate(() => new Date()),
+    taken_at: p.text().nullable(),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
   },
 });

server/src/db/entities/PlaceDetailsCache.entity.ts

@@ -1,24 +1,23 @@
-import { type Opt, PrimaryKeyProp, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, PrimaryKeyProp, defineEntity, p } from '@mikro-orm/core';
+import { PlaceDetailsCacheRepository } from '../repositories/PlaceDetailsCache.repository';
 
 export class PlaceDetailsCache {
-  [PrimaryKeyProp]?: ['placeId', 'lang', 'expanded'];
-  placeId!: string;
+  [PrimaryKeyProp]?: ['place_id', 'lang', 'expanded'];
+  place_id!: string;
   lang: string & Opt = '';
   expanded: number & Opt = 0;
-  payloadJson!: string;
-  fetchedAt!: number;
+  payload_json!: string;
+  fetched_at!: number;
 }
 
-export class PlaceDetailsCacheRepository extends EntityRepository<PlaceDetailsCache> {}
-
 export const PlaceDetailsCacheSchema = defineEntity({
   class: PlaceDetailsCache,
   repository: () => PlaceDetailsCacheRepository,
   properties: {
-    placeId: p.text().primary(),
-    lang: p.text().primary(),
-    expanded: p.integer().primary(),
-    payloadJson: p.text(),
-    fetchedAt: p.integer(),
+    place_id: p.text().primary(),
+    lang: p.text().primary().default(''),
+    expanded: p.integer().primary().default(0),
+    payload_json: p.text(),
+    fetched_at: p.integer(),
   },
 });

server/src/db/entities/PlaceRatings.entity.ts

@@ -1,25 +1,29 @@
-import { type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { PlaceRatingsRepository } from '../repositories/PlaceRatings.repository';
+import { DbTimestampType } from '../types';
 import { Places } from './Places.entity';
 import { Users } from './Users.entity';
 
 export class PlaceRatings {
-  id?: number | null;
+  id!: number & Opt;
   place!: Ref<Places>;
+  place_id!: number;
   user!: Ref<Users>;
+  user_id!: number;
   rating!: number;
-  createdAt?: Date | null;
+  created_at?: string | null;
 }
 
-export class PlaceRatingsRepository extends EntityRepository<PlaceRatings> {}
-
 export const PlaceRatingsSchema = defineEntity({
   class: PlaceRatings,
   repository: () => PlaceRatingsRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    place: () => p.manyToOne(Places).ref().deleteRule('cascade').index('idx_place_ratings_place'),
-    user: () => p.manyToOne(Users).ref().deleteRule('cascade'),
+    id: p.integer().primary(),
+    place: () => p.manyToOne(Places).ref().deleteRule('cascade').hidden().index('idx_place_ratings_place'),
+    place_id: p.integer().persist(false).index('idx_place_ratings_place'),
+    user: () => p.manyToOne(Users).ref().deleteRule('cascade').hidden(),
+    user_id: p.integer().persist(false),
     rating: p.integer(),
-    createdAt: p.datetime().nullable().onCreate(() => new Date()),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
   },
 });

server/src/db/entities/PlaceRegions.entity.ts

@@ -1,23 +1,24 @@
-import { PrimaryKeyProp, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { PrimaryKeyProp, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { PlaceRegionsRepository } from '../repositories/PlaceRegions.repository';
 import { Places } from './Places.entity';
 
 export class PlaceRegions {
   [PrimaryKeyProp]?: 'place';
   place?: Ref<Places> | null;
-  countryCode!: string;
-  regionCode!: string;
-  regionName!: string;
+  place_id?: number | null;
+  country_code!: string;
+  region_code!: string;
+  region_name!: string;
 }
 
-export class PlaceRegionsRepository extends EntityRepository<PlaceRegions> {}
-
 export const PlaceRegionsSchema = defineEntity({
   class: PlaceRegions,
   repository: () => PlaceRegionsRepository,
   properties: {
-    place: () => p.oneToOne(Places).primary().ref().nullable(),
-    countryCode: p.text().index('idx_place_regions_country'),
-    regionCode: p.text().index('idx_place_regions_region'),
-    regionName: p.text(),
+    place: () => p.oneToOne(Places).primary().ref().nullable().hidden(),
+    place_id: p.integer().nullable().persist(false),
+    country_code: p.text().index('idx_place_regions_country'),
+    region_code: p.text().index('idx_place_regions_region'),
+    region_name: p.text(),
   },
 });

server/src/db/entities/PlaceShadowPicks.entity.ts

@@ -1,39 +1,38 @@
-import { type Opt, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, defineEntity, p } from '@mikro-orm/core';
+import { PlaceShadowPicksRepository } from '../repositories/PlaceShadowPicks.repository';
 
 export class PlaceShadowPicks {
-  id?: number | null;
-  createdAt!: string & Opt;
+  id!: number & Opt;
+  created_at!: string & Opt;
   query!: string;
   lang?: string | null;
-  biasLat?: unknown | null;
-  biasLng?: unknown | null;
+  bias_lat?: number | null;
+  bias_lng?: number | null;
   source!: string;
-  liveRank!: number;
-  liveCount!: number;
-  pickedName!: string;
-  pickedLat!: unknown;
-  pickedLng!: unknown;
-  pickedPlaceId?: string | null;
+  live_rank!: number;
+  live_count!: number;
+  picked_name!: string;
+  picked_lat!: number;
+  picked_lng!: number;
+  picked_place_id?: string | null;
 }
 
-export class PlaceShadowPicksRepository extends EntityRepository<PlaceShadowPicks> {}
-
 export const PlaceShadowPicksSchema = defineEntity({
   class: PlaceShadowPicks,
   repository: () => PlaceShadowPicksRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    createdAt: p.text().defaultRaw(`(datetime('now'))`).index('idx_place_shadow_created'),
+    id: p.integer().primary(),
+    created_at: p.text().defaultRaw(`(datetime('now'))`).index('idx_place_shadow_created'),
     query: p.text(),
     lang: p.text().nullable(),
-    biasLat: p.double().nullable(),
-    biasLng: p.double().nullable(),
+    bias_lat: p.double().nullable(),
+    bias_lng: p.double().nullable(),
     source: p.text(),
-    liveRank: p.integer(),
-    liveCount: p.integer(),
-    pickedName: p.text(),
-    pickedLat: p.double(),
-    pickedLng: p.double(),
-    pickedPlaceId: p.text().nullable(),
+    live_rank: p.integer(),
+    live_count: p.integer(),
+    picked_name: p.text(),
+    picked_lat: p.double(),
+    picked_lng: p.double(),
+    picked_place_id: p.text().nullable(),
   },
 });

server/src/db/entities/Places.entity.ts

@@ -1,4 +1,6 @@
-import { Collection, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { Collection, type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { PlacesRepository } from '../repositories/Places.repository';
+import { DbTimestampType } from '../types';
 import { BudgetItems } from './BudgetItems.entity';
 import { Categories } from './Categories.entity';
 import { DawarichVisitSuggestions } from './DawarichVisitSuggestions.entity';
@@ -16,103 +18,105 @@ import { TripFiles } from './TripFiles.entity';
 import { Trips } from './Trips.entity';
 
 export class Places {
-  id?: number | null;
+  id!: number & Opt;
   trip!: Ref<Trips>;
+  trip_id!: number;
   name!: string;
   description?: string | null;
-  lat?: unknown | null;
-  lng?: unknown | null;
+  lat?: number | null;
+  lng?: number | null;
   address?: string | null;
   category?: Ref<Categories> | null;
-  price?: unknown | null;
+  category_id?: number | null;
+  price?: number | null;
   currency?: string | null;
-  reservationStatus?: string | null = 'none';
-  reservationNotes?: string | null;
-  reservationDatetime?: string | null;
-  placeTime?: string | null;
-  endTime?: string | null;
-  durationMinutes?: number | null = 60;
+  reservation_status?: string | null = 'none';
+  reservation_notes?: string | null;
+  reservation_datetime?: string | null;
+  place_time?: string | null;
+  end_time?: string | null;
+  duration_minutes?: number | null = 60;
   notes?: string | null;
-  imageUrl?: string | null;
-  googlePlaceId?: string | null;
-  googleFtid?: string | null;
+  image_url?: string | null;
+  google_place_id?: string | null;
+  google_ftid?: string | null;
   website?: string | null;
   phone?: string | null;
-  transportMode?: string | null = 'walking';
-  createdAt?: Date | null;
-  updatedAt?: Date | null;
-  osmId?: string | null;
-  routeGeometry?: string | null;
-  routeColor?: string | null;
-  stopType?: string | null;
-  fillPercent?: number | null;
-  amapPoiId?: string | null;
+  transport_mode?: string | null = 'walking';
+  created_at?: string | null;
+  updated_at?: string | null;
+  osm_id?: string | null;
+  route_geometry?: string | null;
+  route_color?: string | null;
+  stop_type?: string | null;
+  fill_percent?: number | null;
+  amap_poi_id?: string | null;
   source?: string | null;
-  placeTags = new Collection<Tags>(this);
-  budgetItemsCollection = new Collection<BudgetItems>(this);
-  dawarichVisitSuggestionsCollection = new Collection<DawarichVisitSuggestions>(this);
-  dayAccommodationsCollection = new Collection<DayAccommodations>(this);
-  dayAssignmentsCollection = new Collection<DayAssignments>(this);
-  fileLinksCollection = new Collection<FileLinks>(this);
-  journeyEntriesCollection = new Collection<JourneyEntries>(this);
-  photosCollection = new Collection<Photos>(this);
-  placeRatingsCollection = new Collection<PlaceRatings>(this);
-  placeRegions: Ref<PlaceRegions> | null = null;
-  reservationsCollection = new Collection<Reservations>(this);
-  roadtripDayTracksCollection = new Collection<RoadtripDayTracks>(this);
-  tripFilesCollection = new Collection<TripFiles>(this);
+  place_tags = new Collection<Tags>(this);
+  budget_items_collection = new Collection<BudgetItems>(this);
+  dawarich_visit_suggestions_collection = new Collection<DawarichVisitSuggestions>(this);
+  day_accommodations_collection = new Collection<DayAccommodations>(this);
+  day_assignments_collection = new Collection<DayAssignments>(this);
+  file_links_collection = new Collection<FileLinks>(this);
+  journey_entries_collection = new Collection<JourneyEntries>(this);
+  photos_collection = new Collection<Photos>(this);
+  place_ratings_collection = new Collection<PlaceRatings>(this);
+  place_regions: Ref<PlaceRegions> | null = null;
+  reservations_collection = new Collection<Reservations>(this);
+  roadtrip_day_tracks_collection = new Collection<RoadtripDayTracks>(this);
+  trip_files_collection = new Collection<TripFiles>(this);
 }
 
-export class PlacesRepository extends EntityRepository<Places> {}
-
 export const PlacesSchema = defineEntity({
   class: Places,
   repository: () => PlacesRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    trip: () => p.manyToOne(Trips).ref().deleteRule('cascade').index('idx_places_trip_id'),
+    id: p.integer().primary(),
+    trip: () => p.manyToOne(Trips).ref().deleteRule('cascade').hidden().index('idx_places_trip_id'),
+    trip_id: p.integer().persist(false).index('idx_places_trip_id'),
     name: p.text(),
     description: p.text().nullable(),
     lat: p.double().nullable(),
     lng: p.double().nullable(),
     address: p.text().nullable(),
-    category: () => p.manyToOne(Categories).ref().nullable().index('idx_places_category_id'),
+    category: () => p.manyToOne(Categories).ref().nullable().hidden().index('idx_places_category_id'),
+    category_id: p.integer().nullable().persist(false).index('idx_places_category_id'),
     price: p.double().nullable(),
     currency: p.text().nullable(),
-    reservationStatus: p.text().nullable(),
-    reservationNotes: p.text().nullable(),
-    reservationDatetime: p.text().nullable(),
-    placeTime: p.text().nullable(),
-    endTime: p.text().nullable(),
-    durationMinutes: p.integer().nullable(),
+    reservation_status: p.text().nullable(),
+    reservation_notes: p.text().nullable(),
+    reservation_datetime: p.text().nullable(),
+    place_time: p.text().nullable(),
+    end_time: p.text().nullable(),
+    duration_minutes: p.integer().nullable(),
     notes: p.text().nullable(),
-    imageUrl: p.text().nullable(),
-    googlePlaceId: p.text().nullable(),
-    googleFtid: p.text().nullable(),
+    image_url: p.text().nullable(),
+    google_place_id: p.text().nullable(),
+    google_ftid: p.text().nullable(),
     website: p.text().nullable(),
     phone: p.text().nullable(),
-    transportMode: p.text().nullable(),
-    createdAt: p.datetime().nullable().onCreate(() => new Date()),
-    updatedAt: p.datetime().nullable().onCreate(() => new Date()),
-    osmId: p.text().nullable(),
-    routeGeometry: p.text().nullable(),
-    routeColor: p.text().nullable(),
-    stopType: p.text().nullable(),
-    fillPercent: p.integer().nullable(),
-    amapPoiId: p.text().nullable(),
+    transport_mode: p.text().nullable(),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
+    updated_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
+    osm_id: p.text().nullable(),
+    route_geometry: p.text().nullable(),
+    route_color: p.text().nullable(),
+    stop_type: p.text().nullable(),
+    fill_percent: p.integer().nullable(),
+    amap_poi_id: p.text().nullable(),
     source: p.text().nullable(),
-    placeTags: () => p.manyToMany(Tags).pivotTable('place_tags').joinColumn('place_id').inverseJoinColumn('tag_id'),
-    budgetItemsCollection: () => p.oneToMany(BudgetItems).mappedBy('place'),
-    dawarichVisitSuggestionsCollection: () => p.oneToMany(DawarichVisitSuggestions).mappedBy('acceptedPlace'),
-    dayAccommodationsCollection: () => p.oneToMany(DayAccommodations).mappedBy('place'),
-    dayAssignmentsCollection: () => p.oneToMany(DayAssignments).mappedBy('place'),
-    fileLinksCollection: () => p.oneToMany(FileLinks).mappedBy('place'),
-    journeyEntriesCollection: () => p.oneToMany(JourneyEntries).mappedBy('sourcePlace'),
-    photosCollection: () => p.oneToMany(Photos).mappedBy('place'),
-    placeRatingsCollection: () => p.oneToMany(PlaceRatings).mappedBy('place'),
-    placeRegions: () => p.oneToOne(PlaceRegions).ref().mappedBy('place'),
-    reservationsCollection: () => p.oneToMany(Reservations).mappedBy('place'),
-    roadtripDayTracksCollection: () => p.oneToMany(RoadtripDayTracks).mappedBy('place'),
-    tripFilesCollection: () => p.oneToMany(TripFiles).mappedBy('place'),
+    place_tags: () => p.manyToMany(Tags).pivotTable('place_tags').joinColumn('place_id').inverseJoinColumn('tag_id').hidden(),
+    budget_items_collection: () => p.oneToMany(BudgetItems).mappedBy('place').hidden(),
+    dawarich_visit_suggestions_collection: () => p.oneToMany(DawarichVisitSuggestions).mappedBy('acceptedPlace').hidden(),
+    day_accommodations_collection: () => p.oneToMany(DayAccommodations).mappedBy('place').hidden(),
+    day_assignments_collection: () => p.oneToMany(DayAssignments).mappedBy('place').hidden(),
+    file_links_collection: () => p.oneToMany(FileLinks).mappedBy('place').hidden(),
+    journey_entries_collection: () => p.oneToMany(JourneyEntries).mappedBy('sourcePlace').hidden(),
+    photos_collection: () => p.oneToMany(Photos).mappedBy('place').hidden(),
+    place_ratings_collection: () => p.oneToMany(PlaceRatings).mappedBy('place').hidden(),
+    place_regions: () => p.oneToOne(PlaceRegions).ref().mappedBy('place').hidden(),
+    reservations_collection: () => p.oneToMany(Reservations).mappedBy('place').hidden(),
+    roadtrip_day_tracks_collection: () => p.oneToMany(RoadtripDayTracks).mappedBy('place').hidden(),
+    trip_files_collection: () => p.oneToMany(TripFiles).mappedBy('place').hidden(),
   },
 });

server/src/db/entities/PluginActions.entity.ts

@@ -1,28 +1,27 @@
-import { type Opt, PrimaryKeyProp, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, PrimaryKeyProp, defineEntity, p } from '@mikro-orm/core';
+import { PluginActionsRepository } from '../repositories/PluginActions.repository';
 
 export class PluginActions {
-  [PrimaryKeyProp]?: ['pluginId', 'actionKey'];
-  pluginId!: string;
-  actionKey!: string;
+  [PrimaryKeyProp]?: ['plugin_id', 'action_key'];
+  plugin_id!: string;
+  action_key!: string;
   label!: string;
   hint?: string | null;
   danger: number & Opt = 0;
-  sortOrder: number & Opt = 0;
+  sort_order: number & Opt = 0;
   scope: string & Opt = 'user';
 }
 
-export class PluginActionsRepository extends EntityRepository<PluginActions> {}
-
 export const PluginActionsSchema = defineEntity({
   class: PluginActions,
   repository: () => PluginActionsRepository,
   properties: {
-    pluginId: p.text().primary(),
-    actionKey: p.text().primary(),
+    plugin_id: p.text().primary(),
+    action_key: p.text().primary(),
     label: p.text(),
     hint: p.text().nullable(),
-    danger: p.integer(),
-    sortOrder: p.integer(),
-    scope: p.text(),
+    danger: p.integer().default(0),
+    sort_order: p.integer().default(0),
+    scope: p.text().default('user'),
   },
 });

server/src/db/entities/PluginCapabilityAudit.entity.ts

@@ -1,32 +1,31 @@
-import { type Opt, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, defineEntity, p } from '@mikro-orm/core';
+import { PluginCapabilityAuditRepository } from '../repositories/PluginCapabilityAudit.repository';
 
 export class PluginCapabilityAudit {
-  id?: number | null;
-  pluginId!: string;
-  actingUserId?: number | null;
+  id!: number & Opt;
+  plugin_id!: string;
+  acting_user_id?: number | null;
   method!: string;
   resource?: string | null;
   code!: string;
   ts!: string & Opt;
-  prevHash?: string | null;
+  prev_hash?: string | null;
   hash!: string;
 }
 
-export class PluginCapabilityAuditRepository extends EntityRepository<PluginCapabilityAudit> {}
-
 export const PluginCapabilityAuditSchema = defineEntity({
   class: PluginCapabilityAudit,
   repository: () => PluginCapabilityAuditRepository,
-  indexes: [{ name: 'idx_plugin_audit_plugin', properties: ['pluginId', 'id'] }],
+  indexes: [{ name: 'idx_plugin_audit_plugin', properties: ['plugin_id', 'id'] }],
   properties: {
-    id: p.integer().primary().autoincrement(),
-    pluginId: p.text(),
-    actingUserId: p.integer().nullable(),
+    id: p.integer().primary(),
+    plugin_id: p.text(),
+    acting_user_id: p.integer().nullable(),
     method: p.text(),
     resource: p.text().nullable(),
     code: p.text(),
     ts: p.text().defaultRaw(`(datetime('now'))`),
-    prevHash: p.text().nullable(),
+    prev_hash: p.text().nullable(),
     hash: p.text(),
   },
 });

server/src/db/entities/PluginEgressHosts.entity.ts

@@ -1,21 +1,20 @@
-import { type Opt, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, defineEntity, p } from '@mikro-orm/core';
+import { PluginEgressHostsRepository } from '../repositories/PluginEgressHosts.repository';
 
 export class PluginEgressHosts {
-  id?: number | null;
-  pluginId!: string;
+  id!: number & Opt;
+  plugin_id!: string;
   host!: string;
-  createdAt!: string & Opt;
+  created_at!: string & Opt;
 }
 
-export class PluginEgressHostsRepository extends EntityRepository<PluginEgressHosts> {}
-
 export const PluginEgressHostsSchema = defineEntity({
   class: PluginEgressHosts,
   repository: () => PluginEgressHostsRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    pluginId: p.text().index('idx_plugin_egress_hosts_plugin'),
+    id: p.integer().primary(),
+    plugin_id: p.text().index('idx_plugin_egress_hosts_plugin'),
     host: p.text(),
-    createdAt: p.text().defaultRaw(`(datetime('now'))`),
+    created_at: p.text().defaultRaw(`(datetime('now'))`),
   },
 });

server/src/db/entities/PluginEntityMetadata.entity.ts

@@ -1,33 +1,32 @@
-import { type Opt, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, defineEntity, p } from '@mikro-orm/core';
+import { PluginEntityMetadataRepository } from '../repositories/PluginEntityMetadata.repository';
 
 export class PluginEntityMetadata {
-  id?: number | null;
-  pluginId!: string;
-  entityType!: string;
-  entityId!: number;
+  id!: number & Opt;
+  plugin_id!: string;
+  entity_type!: string;
+  entity_id!: number;
   key!: string;
   value?: string | null;
-  updatedAt!: string & Opt;
+  updated_at!: string & Opt;
 }
 
-export class PluginEntityMetadataRepository extends EntityRepository<PluginEntityMetadata> {}
-
 export const PluginEntityMetadataSchema = defineEntity({
   class: PluginEntityMetadata,
   repository: () => PluginEntityMetadataRepository,
   indexes: [
     {
       name: 'idx_plugin_meta_entity',
-      properties: ['pluginId', 'entityType', 'entityId'],
+      properties: ['plugin_id', 'entity_type', 'entity_id'],
     },
   ],
   properties: {
-    id: p.integer().primary().autoincrement(),
-    pluginId: p.text(),
-    entityType: p.text(),
-    entityId: p.integer(),
+    id: p.integer().primary(),
+    plugin_id: p.text(),
+    entity_type: p.text(),
+    entity_id: p.integer(),
     key: p.text(),
     value: p.text().nullable(),
-    updatedAt: p.text().defaultRaw(`(datetime('now'))`),
+    updated_at: p.text().defaultRaw(`(datetime('now'))`),
   },
 });

server/src/db/entities/PluginErrorLog.entity.ts

@@ -1,27 +1,27 @@
-import { type Opt, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, defineEntity, p } from '@mikro-orm/core';
+import { PluginErrorLogRepository } from '../repositories/PluginErrorLog.repository';
+import { DbTimestampType } from '../types';
 
 export class PluginErrorLog {
-  id?: number | null;
-  pluginId!: string;
-  ts?: Date | null;
+  id!: number & Opt;
+  plugin_id!: string;
+  ts?: string | null;
   level: string & Opt = 'error';
   message?: string | null;
   stack?: string | null;
 }
 
-export class PluginErrorLogRepository extends EntityRepository<PluginErrorLog> {}
-
 export const PluginErrorLogSchema = defineEntity({
   class: PluginErrorLog,
   repository: () => PluginErrorLogRepository,
   indexes: [
-    { name: 'idx_plugin_error_log_plugin', properties: ['pluginId', 'ts'] },
+    { name: 'idx_plugin_error_log_plugin', properties: ['plugin_id', 'ts'] },
   ],
   properties: {
-    id: p.integer().primary().autoincrement(),
-    pluginId: p.text(),
-    ts: p.datetime().nullable().onCreate(() => new Date()),
-    level: p.text(),
+    id: p.integer().primary(),
+    plugin_id: p.text(),
+    ts: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
+    level: p.text().default('error'),
     message: p.text().nullable(),
     stack: p.text().nullable(),
   },

server/src/db/entities/PluginMetaMigrations.entity.ts

@@ -1,20 +1,20 @@
-import { PrimaryKeyProp, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { PrimaryKeyProp, defineEntity, p } from '@mikro-orm/core';
+import { PluginMetaMigrationsRepository } from '../repositories/PluginMetaMigrations.repository';
+import { DbTimestampType } from '../types';
 
 export class PluginMetaMigrations {
-  [PrimaryKeyProp]?: ['pluginId', 'migrationId'];
-  pluginId!: string;
-  migrationId!: string;
-  appliedAt?: Date | null;
+  [PrimaryKeyProp]?: ['plugin_id', 'migration_id'];
+  plugin_id!: string;
+  migration_id!: string;
+  applied_at?: string | null;
 }
 
-export class PluginMetaMigrationsRepository extends EntityRepository<PluginMetaMigrations> {}
-
 export const PluginMetaMigrationsSchema = defineEntity({
   class: PluginMetaMigrations,
   repository: () => PluginMetaMigrationsRepository,
   properties: {
-    pluginId: p.text().primary(),
-    migrationId: p.text().primary(),
-    appliedAt: p.datetime().nullable().onCreate(() => new Date()),
+    plugin_id: p.text().primary(),
+    migration_id: p.text().primary(),
+    applied_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
   },
 });

server/src/db/entities/PluginOauthState.entity.ts

@@ -1,24 +1,23 @@
-import { PrimaryKeyProp, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { PrimaryKeyProp, defineEntity, p } from '@mikro-orm/core';
+import { PluginOauthStateRepository } from '../repositories/PluginOauthState.repository';
 
 export class PluginOauthState {
   [PrimaryKeyProp]?: 'state';
   state?: string | null;
-  pluginId!: string;
-  userId!: number;
+  plugin_id!: string;
+  user_id!: number;
   verifier!: string;
-  createdAt!: number;
+  created_at!: number;
 }
 
-export class PluginOauthStateRepository extends EntityRepository<PluginOauthState> {}
-
 export const PluginOauthStateSchema = defineEntity({
   class: PluginOauthState,
   repository: () => PluginOauthStateRepository,
   properties: {
     state: p.text().primary().nullable(),
-    pluginId: p.text(),
-    userId: p.integer(),
+    plugin_id: p.text(),
+    user_id: p.integer(),
     verifier: p.text(),
-    createdAt: p.integer(),
+    created_at: p.integer(),
   },
 });

server/src/db/entities/PluginOauthTokens.entity.ts

@@ -1,28 +1,27 @@
-import { type Opt, PrimaryKeyProp, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, PrimaryKeyProp, defineEntity, p } from '@mikro-orm/core';
+import { PluginOauthTokensRepository } from '../repositories/PluginOauthTokens.repository';
 
 export class PluginOauthTokens {
-  [PrimaryKeyProp]?: ['pluginId', 'userId'];
-  pluginId!: string;
-  userId!: number;
-  accessToken?: string | null;
-  refreshToken?: string | null;
-  expiresAt?: number | null;
+  [PrimaryKeyProp]?: ['plugin_id', 'user_id'];
+  plugin_id!: string;
+  user_id!: number;
+  access_token?: string | null;
+  refresh_token?: string | null;
+  expires_at?: number | null;
   scope?: string | null;
-  updatedAt!: string & Opt;
+  updated_at!: string & Opt;
 }
 
-export class PluginOauthTokensRepository extends EntityRepository<PluginOauthTokens> {}
-
 export const PluginOauthTokensSchema = defineEntity({
   class: PluginOauthTokens,
   repository: () => PluginOauthTokensRepository,
   properties: {
-    pluginId: p.text().primary(),
-    userId: p.integer().primary(),
-    accessToken: p.text().nullable(),
-    refreshToken: p.text().nullable(),
-    expiresAt: p.integer().nullable(),
+    plugin_id: p.text().primary(),
+    user_id: p.integer().primary(),
+    access_token: p.text().nullable(),
+    refresh_token: p.text().nullable(),
+    expires_at: p.integer().nullable(),
     scope: p.text().nullable(),
-    updatedAt: p.text().defaultRaw(`(datetime('now'))`),
+    updated_at: p.text().defaultRaw(`(datetime('now'))`),
   },
 });

server/src/db/entities/PluginScheduledTasks.entity.ts

@@ -1,27 +1,26 @@
-import { type Opt, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, defineEntity, p } from '@mikro-orm/core';
+import { PluginScheduledTasksRepository } from '../repositories/PluginScheduledTasks.repository';
 
 export class PluginScheduledTasks {
-  id?: number | null;
-  pluginId!: string;
+  id!: number & Opt;
+  plugin_id!: string;
   name!: string;
-  dueAt!: number;
+  due_at!: number;
   payload: string & Opt = 'null';
-  everyMs?: number | null;
-  createdAt!: string & Opt;
+  every_ms?: number | null;
+  created_at!: string & Opt;
 }
 
-export class PluginScheduledTasksRepository extends EntityRepository<PluginScheduledTasks> {}
-
 export const PluginScheduledTasksSchema = defineEntity({
   class: PluginScheduledTasks,
   repository: () => PluginScheduledTasksRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    pluginId: p.text(),
+    id: p.integer().primary(),
+    plugin_id: p.text(),
     name: p.text(),
-    dueAt: p.integer().index('idx_plugin_sched_due'),
-    payload: p.text(),
-    everyMs: p.integer().nullable(),
-    createdAt: p.text().defaultRaw(`(datetime('now'))`),
+    due_at: p.integer().index('idx_plugin_sched_due'),
+    payload: p.text().default('null'),
+    every_ms: p.integer().nullable(),
+    created_at: p.text().defaultRaw(`(datetime('now'))`),
   },
 });

server/src/db/entities/PluginSettingsFields.entity.ts

@@ -1,41 +1,40 @@
-import { type Opt, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, defineEntity, p } from '@mikro-orm/core';
+import { PluginSettingsFieldsRepository } from '../repositories/PluginSettingsFields.repository';
 
 export class PluginSettingsFields {
-  id?: number | null;
-  pluginId!: string;
-  fieldKey!: string;
+  id!: number & Opt;
+  plugin_id!: string;
+  field_key!: string;
   label?: string | null;
-  inputType: string & Opt = 'text';
+  input_type: string & Opt = 'text';
   placeholder?: string | null;
   hint?: string | null;
   required: number & Opt = 0;
   secret: number & Opt = 0;
   scope: string & Opt = 'instance';
   options?: string | null;
-  oauthConfig?: string | null;
-  sortOrder: number & Opt = 0;
-  defaultValue?: string | null;
+  oauth_config?: string | null;
+  sort_order: number & Opt = 0;
+  default_value?: string | null;
 }
 
-export class PluginSettingsFieldsRepository extends EntityRepository<PluginSettingsFields> {}
-
 export const PluginSettingsFieldsSchema = defineEntity({
   class: PluginSettingsFields,
   repository: () => PluginSettingsFieldsRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    pluginId: p.text(),
-    fieldKey: p.text(),
+    id: p.integer().primary(),
+    plugin_id: p.text(),
+    field_key: p.text(),
     label: p.text().nullable(),
-    inputType: p.text(),
+    input_type: p.text().default('text'),
     placeholder: p.text().nullable(),
     hint: p.text().nullable(),
-    required: p.integer(),
-    secret: p.integer(),
-    scope: p.text(),
+    required: p.integer().default(0),
+    secret: p.integer().default(0),
+    scope: p.text().default('instance'),
     options: p.text().nullable(),
-    oauthConfig: p.text().nullable(),
-    sortOrder: p.integer(),
-    defaultValue: p.text().nullable(),
+    oauth_config: p.text().nullable(),
+    sort_order: p.integer().default(0),
+    default_value: p.text().nullable(),
   },
 });

server/src/db/entities/PluginUserConfig.entity.ts

@@ -1,22 +1,21 @@
-import { type Opt, PrimaryKeyProp, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, PrimaryKeyProp, defineEntity, p } from '@mikro-orm/core';
+import { PluginUserConfigRepository } from '../repositories/PluginUserConfig.repository';
 
 export class PluginUserConfig {
-  [PrimaryKeyProp]?: ['pluginId', 'userId'];
-  pluginId!: string;
-  userId!: number;
+  [PrimaryKeyProp]?: ['plugin_id', 'user_id'];
+  plugin_id!: string;
+  user_id!: number;
   config: string & Opt = '{}';
-  updatedAt!: string & Opt;
+  updated_at!: string & Opt;
 }
 
-export class PluginUserConfigRepository extends EntityRepository<PluginUserConfig> {}
-
 export const PluginUserConfigSchema = defineEntity({
   class: PluginUserConfig,
   repository: () => PluginUserConfigRepository,
   properties: {
-    pluginId: p.text().primary(),
-    userId: p.integer().primary(),
-    config: p.text(),
-    updatedAt: p.text().defaultRaw(`(datetime('now'))`),
+    plugin_id: p.text().primary(),
+    user_id: p.integer().primary(),
+    config: p.text().default('{}'),
+    updated_at: p.text().defaultRaw(`(datetime('now'))`),
   },
 });

server/src/db/entities/PluginUserErasureQueue.entity.ts

@@ -1,21 +1,20 @@
-import { type Opt, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, defineEntity, p } from '@mikro-orm/core';
+import { PluginUserErasureQueueRepository } from '../repositories/PluginUserErasureQueue.repository';
 
 export class PluginUserErasureQueue {
-  id?: number | null;
-  pluginId!: string;
-  userId!: number;
-  createdAt!: string & Opt;
+  id!: number & Opt;
+  plugin_id!: string;
+  user_id!: number;
+  created_at!: string & Opt;
 }
 
-export class PluginUserErasureQueueRepository extends EntityRepository<PluginUserErasureQueue> {}
-
 export const PluginUserErasureQueueSchema = defineEntity({
   class: PluginUserErasureQueue,
   repository: () => PluginUserErasureQueueRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    pluginId: p.text().index('idx_plugin_erasure_plugin'),
-    userId: p.integer(),
-    createdAt: p.text().defaultRaw(`(datetime('now'))`),
+    id: p.integer().primary(),
+    plugin_id: p.text().index('idx_plugin_erasure_plugin'),
+    user_id: p.integer(),
+    created_at: p.text().defaultRaw(`(datetime('now'))`),
   },
 });

server/src/db/entities/Plugins.entity.ts

@@ -1,4 +1,6 @@
-import { type Opt, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, defineEntity, p } from '@mikro-orm/core';
+import { PluginsRepository } from '../repositories/Plugins.repository';
+import { DbTimestampType } from '../types';
 
 export class Plugins {
   id?: string | null;
@@ -7,35 +9,33 @@ export class Plugins {
   type: string & Opt = 'integration';
   icon?: string | null = 'Blocks';
   version?: string | null;
-  apiVersion?: number | null = 1;
-  minTrekVersion?: string | null;
+  api_version?: number | null = 1;
+  min_trek_version?: string | null;
   permissions?: string | null = '[]';
-  grantedPermissions?: string | null = '[]';
+  granted_permissions?: string | null = '[]';
   status: string & Opt = 'inactive';
   config?: string | null = '{}';
-  sourceRepo?: string | null;
-  sourceCommit?: string | null;
+  source_repo?: string | null;
+  source_commit?: string | null;
   sha256?: string | null;
-  crashCount: number & Opt = 0;
-  lastError?: string | null;
-  reviewedAt?: string | null;
-  sortOrder: number & Opt = 0;
-  installedAt?: Date | null;
-  updatedAt?: Date | null;
+  crash_count: number & Opt = 0;
+  last_error?: string | null;
+  reviewed_at?: string | null;
+  sort_order: number & Opt = 0;
+  installed_at?: string | null;
+  updated_at?: string | null;
   enabled: number & Opt = 0;
   capabilities: string & Opt = '{}';
-  authorPubkey?: string | null;
+  author_pubkey?: string | null;
   dependencies: string & Opt = '{}';
-  operatorEgress: number & Opt = 0;
-  updateBlockCode?: string | null;
-  updateBlockDetail?: string | null;
-  updateBlockVersion?: string | null;
-  trekRange?: string | null;
-  updateHold: number & Opt = 0;
+  operator_egress: number & Opt = 0;
+  update_block_code?: string | null;
+  update_block_detail?: string | null;
+  update_block_version?: string | null;
+  trek_range?: string | null;
+  update_hold: number & Opt = 0;
 }
 
-export class PluginsRepository extends EntityRepository<Plugins> {}
-
 export const PluginsSchema = defineEntity({
   class: Plugins,
   repository: () => PluginsRepository,
@@ -43,33 +43,33 @@ export const PluginsSchema = defineEntity({
     id: p.text().primary().nullable(),
     name: p.text(),
     description: p.text().nullable(),
-    type: p.text(),
+    type: p.text().default('integration'),
     icon: p.text().nullable(),
     version: p.text().nullable(),
-    apiVersion: p.integer().nullable(),
-    minTrekVersion: p.text().nullable(),
+    api_version: p.integer().nullable(),
+    min_trek_version: p.text().nullable(),
     permissions: p.text().nullable(),
-    grantedPermissions: p.text().nullable(),
-    status: p.text(),
+    granted_permissions: p.text().nullable(),
+    status: p.text().default('inactive'),
     config: p.text().nullable(),
-    sourceRepo: p.text().nullable(),
-    sourceCommit: p.text().nullable(),
+    source_repo: p.text().nullable(),
+    source_commit: p.text().nullable(),
     sha256: p.text().nullable(),
-    crashCount: p.integer(),
-    lastError: p.text().nullable(),
-    reviewedAt: p.text().nullable(),
-    sortOrder: p.integer(),
-    installedAt: p.datetime().nullable().onCreate(() => new Date()),
-    updatedAt: p.datetime().nullable().onCreate(() => new Date()),
-    enabled: p.integer(),
-    capabilities: p.text(),
-    authorPubkey: p.text().nullable(),
-    dependencies: p.text(),
-    operatorEgress: p.integer(),
-    updateBlockCode: p.text().nullable(),
-    updateBlockDetail: p.text().nullable(),
-    updateBlockVersion: p.text().nullable(),
-    trekRange: p.text().nullable(),
-    updateHold: p.integer(),
+    crash_count: p.integer().default(0),
+    last_error: p.text().nullable(),
+    reviewed_at: p.text().nullable(),
+    sort_order: p.integer().default(0),
+    installed_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
+    updated_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
+    enabled: p.integer().default(0),
+    capabilities: p.text().default('{}'),
+    author_pubkey: p.text().nullable(),
+    dependencies: p.text().default('{}'),
+    operator_egress: p.integer().default(0),
+    update_block_code: p.text().nullable(),
+    update_block_detail: p.text().nullable(),
+    update_block_version: p.text().nullable(),
+    trek_range: p.text().nullable(),
+    update_hold: p.integer().default(0),
   },
 });

server/src/db/entities/ReservationDayPositions.entity.ts

@@ -1,22 +1,25 @@
-import { PrimaryKeyProp, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { PrimaryKeyProp, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { ReservationDayPositionsRepository } from '../repositories/ReservationDayPositions.repository';
 import { Days } from './Days.entity';
 import { Reservations } from './Reservations.entity';
 
 export class ReservationDayPositions {
   [PrimaryKeyProp]?: ['reservation', 'day'];
   reservation!: Ref<Reservations>;
+  reservation_id!: number;
   day!: Ref<Days>;
-  position!: unknown;
+  day_id!: number;
+  position!: number;
 }
 
-export class ReservationDayPositionsRepository extends EntityRepository<ReservationDayPositions> {}
-
 export const ReservationDayPositionsSchema = defineEntity({
   class: ReservationDayPositions,
   repository: () => ReservationDayPositionsRepository,
   properties: {
-    reservation: () => p.manyToOne(Reservations).primary().ref(),
-    day: () => p.manyToOne(Days).primary().ref(),
+    reservation: () => p.manyToOne(Reservations).primary().ref().hidden(),
+    reservation_id: p.integer().persist(false),
+    day: () => p.manyToOne(Days).primary().ref().hidden(),
+    day_id: p.integer().persist(false),
     position: p.double(),
   },
 });

server/src/db/entities/ReservationEndpoints.entity.ts

@@ -1,38 +1,40 @@
-import { type Opt, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { ReservationEndpointsRepository } from '../repositories/ReservationEndpoints.repository';
+import { DbTimestampType } from '../types';
 import { Reservations } from './Reservations.entity';
 
 export class ReservationEndpoints {
-  id?: number | null;
+  id!: number & Opt;
   reservation!: Ref<Reservations>;
+  reservation_id!: number;
   role!: string;
   sequence: number & Opt = 0;
   name!: string;
   code?: string | null;
-  lat!: unknown;
-  lng!: unknown;
+  lat!: number;
+  lng!: number;
   timezone?: string | null;
-  localTime?: string | null;
-  localDate?: string | null;
-  createdAt?: Date | null;
+  local_time?: string | null;
+  local_date?: string | null;
+  created_at?: string | null;
 }
 
-export class ReservationEndpointsRepository extends EntityRepository<ReservationEndpoints> {}
-
 export const ReservationEndpointsSchema = defineEntity({
   class: ReservationEndpoints,
   repository: () => ReservationEndpointsRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    reservation: () => p.manyToOne(Reservations).ref().deleteRule('cascade').index('idx_reservation_endpoints_reservation_id'),
+    id: p.integer().primary(),
+    reservation: () => p.manyToOne(Reservations).ref().deleteRule('cascade').hidden().index('idx_reservation_endpoints_reservation_id'),
+    reservation_id: p.integer().persist(false).index('idx_reservation_endpoints_reservation_id'),
     role: p.text(),
-    sequence: p.integer(),
+    sequence: p.integer().default(0),
     name: p.text(),
     code: p.text().nullable(),
     lat: p.double(),
     lng: p.double(),
     timezone: p.text().nullable(),
-    localTime: p.text().nullable(),
-    localDate: p.text().nullable(),
-    createdAt: p.datetime().nullable().onCreate(() => new Date()),
+    local_time: p.text().nullable(),
+    local_date: p.text().nullable(),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
   },
 });

server/src/db/entities/ReservationTravelers.entity.ts

@@ -1,21 +1,24 @@
-import { type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { ReservationTravelersRepository } from '../repositories/ReservationTravelers.repository';
 import { Reservations } from './Reservations.entity';
 import { Users } from './Users.entity';
 
 export class ReservationTravelers {
-  id?: number | null;
+  id!: number & Opt;
   reservation!: Ref<Reservations>;
+  reservation_id!: number;
   user!: Ref<Users>;
+  user_id!: number;
 }
 
-export class ReservationTravelersRepository extends EntityRepository<ReservationTravelers> {}
-
 export const ReservationTravelersSchema = defineEntity({
   class: ReservationTravelers,
   repository: () => ReservationTravelersRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    reservation: () => p.manyToOne(Reservations).ref().index('idx_reservation_travelers_res'),
-    user: () => p.manyToOne(Users).ref().index('idx_reservation_travelers_user'),
+    id: p.integer().primary(),
+    reservation: () => p.manyToOne(Reservations).ref().hidden().index('idx_reservation_travelers_res'),
+    reservation_id: p.integer().persist(false).index('idx_reservation_travelers_res'),
+    user: () => p.manyToOne(Users).ref().hidden().index('idx_reservation_travelers_user'),
+    user_id: p.integer().persist(false).index('idx_reservation_travelers_user'),
   },
 });

server/src/db/entities/Reservations.entity.ts

@@ -1,4 +1,6 @@
-import { Collection, type Opt, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { Collection, type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { ReservationsRepository } from '../repositories/Reservations.repository';
+import { DbTimestampType } from '../types';
 import { BudgetItems } from './BudgetItems.entity';
 import { DayAssignments } from './DayAssignments.entity';
 import { Days } from './Days.entity';
@@ -11,85 +13,93 @@ import { TripFiles } from './TripFiles.entity';
 import { Trips } from './Trips.entity';
 
 export class Reservations {
-  id?: number | null;
+  id!: number & Opt;
   trip!: Ref<Trips>;
+  trip_id!: number;
   day?: Ref<Days> | null;
+  day_id?: number | null;
   endDay?: Ref<Days> | null;
+  end_day_id?: number | null;
   place?: Ref<Places> | null;
+  place_id?: number | null;
   assignment?: Ref<DayAssignments> | null;
+  assignment_id?: number | null;
   title!: string;
-  accommodationId?: string | null;
-  reservationTime?: string | null;
-  reservationEndTime?: string | null;
+  accommodation_id?: string | null;
+  reservation_time?: string | null;
+  reservation_end_time?: string | null;
   location?: string | null;
-  confirmationNumber?: string | null;
+  confirmation_number?: string | null;
   notes?: string | null;
   status?: string | null = 'pending';
   type?: string | null = 'other';
-  createdAt?: Date | null;
+  created_at?: string | null;
   metadata?: string | null;
-  dayPlanPosition?: unknown | null;
-  needsReview: number & Opt = 0;
-  externalSource?: string | null;
-  externalId?: string | null;
-  externalOwnerUserId?: number | null;
-  externalSyncedAt?: string | null;
-  syncEnabled?: number | null = 1;
-  externalHash?: string | null;
+  day_plan_position?: number | null;
+  needs_review: number & Opt = 0;
+  external_source?: string | null;
+  external_id?: string | null;
+  external_owner_user_id?: number | null;
+  external_synced_at?: string | null;
+  sync_enabled?: number | null = 1;
+  external_hash?: string | null;
   url?: string | null;
-  ingestState: string & Opt = 'live';
-  budgetItemsCollection = new Collection<BudgetItems>(this);
-  fileLinksCollection = new Collection<FileLinks>(this);
-  reservationDayPositionsCollection = new Collection<ReservationDayPositions>(this);
-  reservationEndpointsCollection = new Collection<ReservationEndpoints>(this);
-  reservationTravelersCollection = new Collection<ReservationTravelers>(this);
-  tripFilesCollection = new Collection<TripFiles>(this);
+  ingest_state: string & Opt = 'live';
+  budget_items_collection = new Collection<BudgetItems>(this);
+  file_links_collection = new Collection<FileLinks>(this);
+  reservation_day_positions_collection = new Collection<ReservationDayPositions>(this);
+  reservation_endpoints_collection = new Collection<ReservationEndpoints>(this);
+  reservation_travelers_collection = new Collection<ReservationTravelers>(this);
+  trip_files_collection = new Collection<TripFiles>(this);
 }
 
-export class ReservationsRepository extends EntityRepository<Reservations> {}
-
 export const ReservationsSchema = defineEntity({
   class: Reservations,
   repository: () => ReservationsRepository,
   uniques: [
     {
       name: 'idx_reservations_external',
-      properties: ['externalSource', 'externalId', 'trip'],
+      properties: ['external_source', 'external_id', 'trip_id'],
     },
   ],
   properties: {
-    id: p.integer().primary().autoincrement(),
-    trip: () => p.manyToOne(Trips).ref().deleteRule('cascade').index('idx_reservations_trip_id'),
-    day: () => p.manyToOne(Days).ref().nullable().index('idx_reservations_day_id'),
-    endDay: () => p.manyToOne(Days).ref().nullable(),
-    place: () => p.manyToOne(Places).ref().nullable(),
-    assignment: () => p.manyToOne(DayAssignments).ref().nullable(),
+    id: p.integer().primary(),
+    trip: () => p.manyToOne(Trips).ref().deleteRule('cascade').hidden().index('idx_reservations_trip_id'),
+    trip_id: p.integer().persist(false).index('idx_reservations_trip_id'),
+    day: () => p.manyToOne(Days).ref().nullable().hidden().index('idx_reservations_day_id'),
+    day_id: p.integer().nullable().persist(false).index('idx_reservations_day_id'),
+    endDay: () => p.manyToOne(Days).ref().nullable().hidden(),
+    end_day_id: p.integer().nullable().persist(false),
+    place: () => p.manyToOne(Places).ref().nullable().hidden(),
+    place_id: p.integer().nullable().persist(false),
+    assignment: () => p.manyToOne(DayAssignments).ref().nullable().hidden(),
+    assignment_id: p.integer().nullable().persist(false),
     title: p.text(),
-    accommodationId: p.text().nullable(),
-    reservationTime: p.text().nullable(),
-    reservationEndTime: p.text().nullable(),
+    accommodation_id: p.text().nullable(),
+    reservation_time: p.text().nullable(),
+    reservation_end_time: p.text().nullable(),
     location: p.text().nullable(),
-    confirmationNumber: p.text().nullable(),
+    confirmation_number: p.text().nullable(),
     notes: p.text().nullable(),
     status: p.text().nullable(),
     type: p.text().nullable(),
-    createdAt: p.datetime().nullable().onCreate(() => new Date()),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
     metadata: p.text().nullable(),
-    dayPlanPosition: p.double().nullable(),
-    needsReview: p.integer(),
-    externalSource: p.text().nullable(),
-    externalId: p.text().nullable(),
-    externalOwnerUserId: p.integer().nullable(),
-    externalSyncedAt: p.text().nullable(),
-    syncEnabled: p.integer().nullable(),
-    externalHash: p.text().nullable(),
+    day_plan_position: p.double().nullable().defaultRaw(`NULL`),
+    needs_review: p.integer().default(0),
+    external_source: p.text().nullable(),
+    external_id: p.text().nullable(),
+    external_owner_user_id: p.integer().nullable(),
+    external_synced_at: p.text().nullable(),
+    sync_enabled: p.integer().nullable(),
+    external_hash: p.text().nullable(),
     url: p.text().nullable(),
-    ingestState: p.text(),
-    budgetItemsCollection: () => p.oneToMany(BudgetItems).mappedBy('reservation'),
-    fileLinksCollection: () => p.oneToMany(FileLinks).mappedBy('reservation'),
-    reservationDayPositionsCollection: () => p.oneToMany(ReservationDayPositions).mappedBy('reservation'),
-    reservationEndpointsCollection: () => p.oneToMany(ReservationEndpoints).mappedBy('reservation'),
-    reservationTravelersCollection: () => p.oneToMany(ReservationTravelers).mappedBy('reservation'),
-    tripFilesCollection: () => p.oneToMany(TripFiles).mappedBy('reservation'),
+    ingest_state: p.text().default('live'),
+    budget_items_collection: () => p.oneToMany(BudgetItems).mappedBy('reservation').hidden(),
+    file_links_collection: () => p.oneToMany(FileLinks).mappedBy('reservation').hidden(),
+    reservation_day_positions_collection: () => p.oneToMany(ReservationDayPositions).mappedBy('reservation').hidden(),
+    reservation_endpoints_collection: () => p.oneToMany(ReservationEndpoints).mappedBy('reservation').hidden(),
+    reservation_travelers_collection: () => p.oneToMany(ReservationTravelers).mappedBy('reservation').hidden(),
+    trip_files_collection: () => p.oneToMany(TripFiles).mappedBy('reservation').hidden(),
   },
 });

server/src/db/entities/RoadtripDayBoundaries.entity.ts

@@ -1,52 +1,41 @@
+import { PrimaryKeyProp, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { RoadtripDayBoundariesRepository } from '../repositories/RoadtripDayBoundaries.repository';
 import { DayAssignments } from './DayAssignments.entity';
 import { Trips } from './Trips.entity';
-import { PrimaryKeyProp, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
 
 export class RoadtripDayBoundaries {
-  [PrimaryKeyProp]?: ['trip', 'dayNumber'];
+  [PrimaryKeyProp]?: ['trip', 'day_number'];
   trip!: Ref<Trips>;
-  dayNumber!: number;
+  trip_id!: number;
+  day_number!: number;
   fromAssignment!: Ref<DayAssignments>;
+  from_assignment_id!: number;
   toAssignment?: Ref<DayAssignments> | null;
-  fraction!: number; // was `unknown`
+  to_assignment_id?: number | null;
+  fraction!: number;
 }
 
-export class RoadtripDayBoundariesRepository extends EntityRepository<RoadtripDayBoundaries> {}
-
 export const RoadtripDayBoundariesSchema = defineEntity({
   class: RoadtripDayBoundaries,
   repository: () => RoadtripDayBoundariesRepository,
   checks: [
     {
       name: 'roadtrip_day_boundaries_fraction_check',
-      expression: 'fraction BETWEEN 0 AND 1',
+      expression: 'fraction BETWEEN 0 AND 1),        PRIMARY KEY (trip_id, day_number',
     },
     {
       name: 'roadtrip_day_boundaries_day_number_check',
-      expression: 'day_number BETWEEN 1 AND 366',
+      expression: 'day_number >= 1',
     },
   ],
   properties: {
-    trip: () => p.manyToOne(Trips).primary().ref().deleteRule('cascade'),
-    dayNumber: p.integer().primary(),
-    fromAssignment: () => p.manyToOne(DayAssignments).ref().deleteRule('cascade'),
-    toAssignment: () => p.manyToOne(DayAssignments).ref().deleteRule('cascade').nullable(),
+    trip: () => p.manyToOne(Trips).primary().ref().deleteRule('cascade').hidden(),
+    trip_id: p.integer().persist(false),
+    day_number: p.integer().primary(),
+    fromAssignment: () => p.manyToOne(DayAssignments).ref().deleteRule('cascade').hidden(),
+    from_assignment_id: p.integer().persist(false),
+    toAssignment: () => p.manyToOne(DayAssignments).ref().deleteRule('cascade').nullable().hidden(),
+    to_assignment_id: p.integer().nullable().persist(false),
     fraction: p.double(),
   },
 });

server/src/db/entities/RoadtripDayTracks.entity.ts

@@ -1,27 +1,27 @@
+import { PrimaryKeyProp, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { RoadtripDayTracksRepository } from '../repositories/RoadtripDayTracks.repository';
 import { Days } from './Days.entity';
 import { Places } from './Places.entity';
-import { defineEntity, EntityRepository, p, PrimaryKeyProp, type Ref } from '@mikro-orm/core';
 
 export class RoadtripDayTracks {
   [PrimaryKeyProp]?: 'day';
   day?: Ref<Days> | null;
+  day_id?: number | null;
   place!: Ref<Places>;
-  strayKm?: unknown | null;
-  createdAt?: string | null;
+  place_id!: number;
+  stray_km?: number | null;
+  created_at?: string | null;
 }
 
-export class RoadtripDayTracksRepository extends EntityRepository<RoadtripDayTracks> {}
-
 export const RoadtripDayTracksSchema = defineEntity({
   class: RoadtripDayTracks,
   repository: () => RoadtripDayTracksRepository,
   properties: {
-    day: () => p.oneToOne(Days).primary().ref().nullable(),
-    place: () => p.manyToOne(Places).ref().deleteRule('cascade').index('idx_roadtrip_day_tracks_place'),
-    strayKm: p.double().nullable(),
-    createdAt: p
-      .text()
-      .nullable()
-      .onCreate(() => new Date().toISOString().replace(/\.\d{3}Z$/, 'Z')),
+    day: () => p.oneToOne(Days).primary().ref().nullable().hidden(),
+    day_id: p.integer().nullable().persist(false),
+    place: () => p.manyToOne(Places).ref().deleteRule('cascade').hidden().index('idx_roadtrip_day_tracks_place'),
+    place_id: p.integer().persist(false).index('idx_roadtrip_day_tracks_place'),
+    stray_km: p.double().nullable(),
+    created_at: p.text().nullable().defaultRaw(`CURRENT_TIMESTAMP`),
   },
 });

server/src/db/entities/RoadtripPreferences.entity.ts

@@ -1,20 +1,21 @@
-import { PrimaryKeyProp, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { PrimaryKeyProp, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { RoadtripPreferencesRepository } from '../repositories/RoadtripPreferences.repository';
 import { Trips } from './Trips.entity';
 
 export class RoadtripPreferences {
   [PrimaryKeyProp]?: ['trip', 'key'];
   trip!: Ref<Trips>;
+  trip_id!: number;
   key!: string;
   value!: string;
 }
 
-export class RoadtripPreferencesRepository extends EntityRepository<RoadtripPreferences> {}
-
 export const RoadtripPreferencesSchema = defineEntity({
   class: RoadtripPreferences,
   repository: () => RoadtripPreferencesRepository,
   properties: {
-    trip: () => p.manyToOne(Trips).primary().ref().deleteRule('cascade'),
+    trip: () => p.manyToOne(Trips).primary().ref().deleteRule('cascade').hidden(),
+    trip_id: p.integer().persist(false),
     key: p.text().primary(),
     value: p.text(),
   },

server/src/db/entities/RoadtripVias.entity.ts

@@ -1,37 +1,35 @@
+import { type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { RoadtripViasRepository } from '../repositories/RoadtripVias.repository';
 import { Days } from './Days.entity';
-import { defineEntity, EntityRepository, type Opt, p, type Ref } from '@mikro-orm/core';
 
 export class RoadtripVias {
-  id?: number | null;
+  id!: number & Opt;
   day!: Ref<Days>;
-  afterOrderIndex!: number;
+  day_id!: number;
+  after_order_index!: number;
   sequence: number & Opt = 0;
-  lat!: unknown;
-  lng!: unknown;
-  createdAt?: string | null;
+  lat!: number;
+  lng!: number;
+  created_at?: string | null;
 }
 
-export class RoadtripViasRepository extends EntityRepository<RoadtripVias> {}
-
 export const RoadtripViasSchema = defineEntity({
   class: RoadtripVias,
   repository: () => RoadtripViasRepository,
   indexes: [
     {
       name: 'idx_roadtrip_vias_day',
-      properties: ['day', 'afterOrderIndex', 'sequence'],
+      properties: ['day_id', 'after_order_index', 'sequence'],
     },
   ],
   properties: {
-    id: p.integer().primary().autoincrement(),
-    day: () => p.manyToOne(Days).ref().deleteRule('cascade'),
-    afterOrderIndex: p.integer(),
-    sequence: p.integer(),
+    id: p.integer().primary(),
+    day: () => p.manyToOne(Days).ref().deleteRule('cascade').hidden(),
+    day_id: p.integer().persist(false),
+    after_order_index: p.integer(),
+    sequence: p.integer().default(0),
     lat: p.double(),
     lng: p.double(),
-    createdAt: p
-      .text()
-      .nullable()
-      .onCreate(() => new Date().toISOString().replace(/\.\d{3}Z$/, 'Z')),
+    created_at: p.text().nullable().defaultRaw(`CURRENT_TIMESTAMP`),
   },
 });

server/src/db/entities/RouteUsageDaily.entity.ts

@@ -1,19 +1,18 @@
-import { type Opt, PrimaryKeyProp, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, PrimaryKeyProp, defineEntity, p } from '@mikro-orm/core';
+import { RouteUsageDailyRepository } from '../repositories/RouteUsageDaily.repository';
 
 export class RouteUsageDaily {
-  [PrimaryKeyProp]?: ['day', 'profile', 'surface', 'selfHosted'];
+  [PrimaryKeyProp]?: ['day', 'profile', 'surface', 'self_hosted'];
   day!: string;
   profile!: string;
   surface!: string;
-  selfHosted!: number;
+  self_hosted!: number;
   requests: number & Opt = 0;
   waypoints: number & Opt = 0;
-  km!: number;
+  km!: number & Opt;
   failed: number & Opt = 0;
 }
 
-export class RouteUsageDailyRepository extends EntityRepository<RouteUsageDaily> {}
-
 export const RouteUsageDailySchema = defineEntity({
   class: RouteUsageDaily,
   repository: () => RouteUsageDailyRepository,
@@ -21,10 +20,10 @@ export const RouteUsageDailySchema = defineEntity({
     day: p.text().primary().index('idx_route_usage_day'),
     profile: p.text().primary(),
     surface: p.text().primary(),
-    selfHosted: p.integer().primary(),
-    requests: p.integer(),
-    waypoints: p.integer(),
-    km: p.double().default(0),
-    failed: p.integer(),
+    self_hosted: p.integer().primary(),
+    requests: p.integer().default(0),
+    waypoints: p.integer().default(0),
+    km: p.double().defaultRaw(`0`),
+    failed: p.integer().default(0),
   },
 });

server/src/db/entities/SchemaVersion.entity.ts

@@ -1,17 +1,16 @@
-import { defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, defineEntity, p } from '@mikro-orm/core';
+import { SchemaVersionRepository } from '../repositories/SchemaVersion.repository';
 
 export class SchemaVersion {
-  id?: number | null;
+  id!: number & Opt;
   version!: number;
 }
 
-export class SchemaVersionRepository extends EntityRepository<SchemaVersion> {}
-
 export const SchemaVersionSchema = defineEntity({
   class: SchemaVersion,
   repository: () => SchemaVersionRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
+    id: p.integer().primary(),
     version: p.integer(),
   },
 });

server/src/db/entities/SchoolHolidayCountries.entity.ts

@@ -1,21 +1,20 @@
-import { Collection, PrimaryKeyProp, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { Collection, PrimaryKeyProp, defineEntity, p } from '@mikro-orm/core';
+import { SchoolHolidayCountriesRepository } from '../repositories/SchoolHolidayCountries.repository';
 import { SchoolHolidayRegions } from './SchoolHolidayRegions.entity';
 
 export class SchoolHolidayCountries {
   [PrimaryKeyProp]?: 'code';
   code?: string | null;
   name!: string;
-  schoolHolidayRegionsCollection = new Collection<SchoolHolidayRegions>(this);
+  school_holiday_regions_collection = new Collection<SchoolHolidayRegions>(this);
 }
 
-export class SchoolHolidayCountriesRepository extends EntityRepository<SchoolHolidayCountries> {}
-
 export const SchoolHolidayCountriesSchema = defineEntity({
   class: SchoolHolidayCountries,
   repository: () => SchoolHolidayCountriesRepository,
   properties: {
     code: p.text().primary().nullable(),
     name: p.text(),
-    schoolHolidayRegionsCollection: () => p.oneToMany(SchoolHolidayRegions).mappedBy('country'),
+    school_holiday_regions_collection: () => p.oneToMany(SchoolHolidayRegions).mappedBy('countryRef').hidden(),
   },
 });

server/src/db/entities/SchoolHolidayPeriods.entity.ts

@@ -1,16 +1,16 @@
-import { type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { SchoolHolidayPeriodsRepository } from '../repositories/SchoolHolidayPeriods.repository';
 import { SchoolHolidayRegions } from './SchoolHolidayRegions.entity';
 
 export class SchoolHolidayPeriods {
-  id?: number | null;
+  id!: number & Opt;
   region!: Ref<SchoolHolidayRegions>;
+  region_id!: number;
   name!: string;
-  startDate!: string;
-  endDate!: string;
+  start_date!: string;
+  end_date!: string;
 }
 
-export class SchoolHolidayPeriodsRepository extends EntityRepository<SchoolHolidayPeriods> {}
-
 export const SchoolHolidayPeriodsSchema = defineEntity({
   class: SchoolHolidayPeriods,
   repository: () => SchoolHolidayPeriodsRepository,
@@ -21,10 +21,11 @@ export const SchoolHolidayPeriodsSchema = defineEntity({
     },
   ],
   properties: {
-    id: p.integer().primary().autoincrement(),
-    region: () => p.manyToOne(SchoolHolidayRegions).ref().deleteRule('cascade').index('idx_school_holiday_periods_region'),
+    id: p.integer().primary(),
+    region: () => p.manyToOne(SchoolHolidayRegions).ref().deleteRule('cascade').hidden().index('idx_school_holiday_periods_region'),
+    region_id: p.integer().persist(false).index('idx_school_holiday_periods_region'),
     name: p.text(),
-    startDate: p.text(),
-    endDate: p.text(),
+    start_date: p.text(),
+    end_date: p.text(),
   },
 });

server/src/db/entities/SchoolHolidayRegions.entity.ts

@@ -1,25 +1,26 @@
-import { Collection, type Opt, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { Collection, type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { SchoolHolidayRegionsRepository } from '../repositories/SchoolHolidayRegions.repository';
 import { SchoolHolidayCountries } from './SchoolHolidayCountries.entity';
 import { SchoolHolidayPeriods } from './SchoolHolidayPeriods.entity';
 
 export class SchoolHolidayRegions {
-  id?: number | null;
-  country!: Ref<SchoolHolidayCountries>;
+  id!: number & Opt;
+  country!: string;
   name!: string;
   revision: number & Opt = 1;
-  schoolHolidayPeriodsCollection = new Collection<SchoolHolidayPeriods>(this);
+  countryRef!: Ref<SchoolHolidayCountries>;
+  school_holiday_periods_collection = new Collection<SchoolHolidayPeriods>(this);
 }
 
-export class SchoolHolidayRegionsRepository extends EntityRepository<SchoolHolidayRegions> {}
-
 export const SchoolHolidayRegionsSchema = defineEntity({
   class: SchoolHolidayRegions,
   repository: () => SchoolHolidayRegionsRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    country: () => p.manyToOne(SchoolHolidayCountries).ref().joinColumn('country'),
+    id: p.integer().primary(),
+    country: p.text().persist(false),
     name: p.text().collation('NOCASE'),
-    revision: p.integer(),
-    schoolHolidayPeriodsCollection: () => p.oneToMany(SchoolHolidayPeriods).mappedBy('region'),
+    revision: p.integer().default(1),
+    countryRef: () => p.manyToOne(SchoolHolidayCountries).ref().joinColumn('country').hidden(),
+    school_holiday_periods_collection: () => p.oneToMany(SchoolHolidayPeriods).mappedBy('region').hidden(),
   },
 });

server/src/db/entities/Settings.entity.ts

@@ -1,21 +1,22 @@
-import { type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { SettingsRepository } from '../repositories/Settings.repository';
 import { Users } from './Users.entity';
 
 export class Settings {
-  id?: number | null;
+  id!: number & Opt;
   user!: Ref<Users>;
+  user_id!: number;
   key!: string;
   value?: string | null;
 }
 
-export class SettingsRepository extends EntityRepository<Settings> {}
-
 export const SettingsSchema = defineEntity({
   class: Settings,
   repository: () => SettingsRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    user: () => p.manyToOne(Users).ref().deleteRule('cascade'),
+    id: p.integer().primary(),
+    user: () => p.manyToOne(Users).ref().deleteRule('cascade').hidden(),
+    user_id: p.integer().persist(false),
     key: p.text(),
     value: p.text().nullable(),
   },

server/src/db/entities/ShareTokens.entity.ts

@@ -1,37 +1,41 @@
-import { type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { ShareTokensRepository } from '../repositories/ShareTokens.repository';
+import { DbTimestampType } from '../types';
 import { Trips } from './Trips.entity';
 import { Users } from './Users.entity';
 
 export class ShareTokens {
-  id?: number | null;
+  id!: number & Opt;
   trip!: Ref<Trips>;
+  trip_id!: number;
   token!: string;
-  createdBy!: Ref<Users>;
-  shareMap?: number | null = 1;
-  shareBookings?: number | null = 1;
-  sharePacking?: number | null = 0;
-  shareBudget?: number | null = 0;
-  shareCollab?: number | null = 0;
-  createdAt?: Date | null;
-  expiresAt?: string | null;
+  created_by!: number;
+  share_map?: number | null = 1;
+  share_bookings?: number | null = 1;
+  share_packing?: number | null = 0;
+  share_budget?: number | null = 0;
+  share_collab?: number | null = 0;
+  created_at?: string | null;
+  expires_at?: string | null;
+  createdByRef!: Ref<Users>;
 }
 
-export class ShareTokensRepository extends EntityRepository<ShareTokens> {}
-
 export const ShareTokensSchema = defineEntity({
   class: ShareTokens,
   repository: () => ShareTokensRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    trip: () => p.manyToOne(Trips).ref().deleteRule('cascade'),
+    id: p.integer().primary(),
+    trip: () => p.manyToOne(Trips).ref().deleteRule('cascade').hidden(),
+    trip_id: p.integer().persist(false),
     token: p.text().index('idx_share_tokens_token'),
-    createdBy: () => p.manyToOne(Users).ref().name('created_by'),
-    shareMap: p.integer().nullable(),
-    shareBookings: p.integer().nullable(),
-    sharePacking: p.integer().nullable(),
-    shareBudget: p.integer().nullable(),
-    shareCollab: p.integer().nullable(),
-    createdAt: p.datetime().nullable().onCreate(() => new Date()),
-    expiresAt: p.text().nullable(),
+    created_by: p.integer().persist(false),
+    share_map: p.integer().nullable(),
+    share_bookings: p.integer().nullable(),
+    share_packing: p.integer().nullable(),
+    share_budget: p.integer().nullable(),
+    share_collab: p.integer().nullable(),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
+    expires_at: p.text().nullable(),
+    createdByRef: () => p.manyToOne(Users).ref().joinColumn('created_by').hidden(),
   },
 });

server/src/db/entities/Tags.entity.ts

@@ -1,30 +1,32 @@
-import { Collection, type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { Collection, type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { TagsRepository } from '../repositories/Tags.repository';
+import { DbTimestampType } from '../types';
 import { CollectionPlaces } from './CollectionPlaces.entity';
 import { Places } from './Places.entity';
 import { Users } from './Users.entity';
 
 export class Tags {
-  id?: number | null;
+  id!: number & Opt;
   user!: Ref<Users>;
+  user_id!: number;
   name!: string;
   color?: string | null = '#10b981';
-  createdAt?: Date | null;
-  collectionPlaceTagsInverse = new Collection<CollectionPlaces>(this);
-  placeTagsInverse = new Collection<Places>(this);
+  created_at?: string | null;
+  collection_place_tags_inverse = new Collection<CollectionPlaces>(this);
+  place_tags_inverse = new Collection<Places>(this);
 }
 
-export class TagsRepository extends EntityRepository<Tags> {}
-
 export const TagsSchema = defineEntity({
   class: Tags,
   repository: () => TagsRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    user: () => p.manyToOne(Users).ref().deleteRule('cascade'),
+    id: p.integer().primary(),
+    user: () => p.manyToOne(Users).ref().deleteRule('cascade').hidden(),
+    user_id: p.integer().persist(false),
     name: p.text(),
     color: p.text().nullable(),
-    createdAt: p.datetime().nullable().onCreate(() => new Date()),
-    collectionPlaceTagsInverse: () => p.manyToMany(CollectionPlaces).mappedBy('collectionPlaceTags'),
-    placeTagsInverse: () => p.manyToMany(Places).mappedBy('placeTags'),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
+    collection_place_tags_inverse: () => p.manyToMany(CollectionPlaces).mappedBy('collection_place_tags').hidden(),
+    place_tags_inverse: () => p.manyToMany(Places).mappedBy('place_tags').hidden(),
   },
 });

server/src/db/entities/TodoCategoryAssignees.entity.ts

@@ -1,23 +1,26 @@
-import { type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { TodoCategoryAssigneesRepository } from '../repositories/TodoCategoryAssignees.repository';
 import { Trips } from './Trips.entity';
 import { Users } from './Users.entity';
 
 export class TodoCategoryAssignees {
-  id?: number | null;
+  id!: number & Opt;
   trip!: Ref<Trips>;
-  categoryName!: string;
+  trip_id!: number;
+  category_name!: string;
   user!: Ref<Users>;
+  user_id!: number;
 }
 
-export class TodoCategoryAssigneesRepository extends EntityRepository<TodoCategoryAssignees> {}
-
 export const TodoCategoryAssigneesSchema = defineEntity({
   class: TodoCategoryAssignees,
   repository: () => TodoCategoryAssigneesRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    trip: () => p.manyToOne(Trips).ref().deleteRule('cascade'),
-    categoryName: p.text(),
-    user: () => p.manyToOne(Users).ref().deleteRule('cascade'),
+    id: p.integer().primary(),
+    trip: () => p.manyToOne(Trips).ref().deleteRule('cascade').hidden(),
+    trip_id: p.integer().persist(false),
+    category_name: p.text(),
+    user: () => p.manyToOne(Users).ref().deleteRule('cascade').hidden(),
+    user_id: p.integer().persist(false),
   },
 });

server/src/db/entities/TodoItems.entity.ts

@@ -1,39 +1,43 @@
-import { type Ref, defineEntity, p, EntityRepository } from '@mikro-orm/core';
+import { type Opt, type Ref, defineEntity, p } from '@mikro-orm/core';
+import { TodoItemsRepository } from '../repositories/TodoItems.repository';
+import { DbTimestampType } from '../types';
 import { Trips } from './Trips.entity';
 import { Users } from './Users.entity';
 
 export class TodoItems {
-  id?: number | null;
+  id!: number & Opt;
   trip!: Ref<Trips>;
+  trip_id!: number;
   name!: string;
   checked?: number | null = 0;
   category?: string | null;
-  sortOrder?: number | null = 0;
-  dueDate?: string | null;
+  sort_order?: number | null = 0;
+  due_date?: string | null;
   description?: string | null;
   assignedUser?: Ref<Users> | null;
+  assigned_user_id?: number | null;
   priority?: number | null = 0;
-  createdAt?: Date | null;
-  remindedAt?: Date | null;
+  created_at?: string | null;
+  reminded_at?: string | null;
 }
 
-export class TodoItemsRepository extends EntityRepository<TodoItems> {}
-
 export const TodoItemsSchema = defineEntity({
   class: TodoItems,
   repository: () => TodoItemsRepository,
   properties: {
-    id: p.integer().primary().autoincrement(),
-    trip: () => p.manyToOne(Trips).ref().deleteRule('cascade').index('idx_todo_items_trip_id'),
+    id: p.integer().primary(),
+    trip: () => p.manyToOne(Trips).ref().deleteRule('cascade').hidden().index('idx_todo_items_trip_id'),
+    trip_id: p.integer().persist(false).index('idx_todo_items_trip_id'),
     name: p.text(),
     checked: p.integer().nullable(),
     category: p.text().nullable(),
-    sortOrder: p.integer().nullable(),
-    dueDate: p.text().nullable(),
+    sort_order: p.integer().nullable(),
+    due_date: p.text().nullable(),
     description: p.text().nullable(),
-    assignedUser: () => p.manyToOne(Users).ref().nullable(),
+    assignedUser: () => p.manyToOne(Users).ref().nullable().hidden(),
+    assigned_user_id: p.integer().nullable().persist(false),
     priority: p.integer().nullable(),
-    createdAt: p.datetime().nullable().onCreate(() => new Date()),
-    remindedAt: p.datetime().nullable(),
+    created_at: p.type(DbTimestampType).nullable().defaultRaw(`CURRENT_TIMESTAMP`),
+    reminded_at: p.type(DbTimestampType).nullable(),
   },
 });