Fix production build crash by resolving circular import dependency

Moved database schemas from src-tauri/database/schemas/ to src/database/schemas/
to fix bundling issues and resolved circular import dependency that caused
"Cannot access uninitialized variable" error in production builds.

Key changes:
- Moved crdtColumnNames definition into haex.ts to break circular dependency
- Restored .$defaultFn(() => crypto.randomUUID()) calls
- Kept AnySQLiteColumn type annotations
- Removed obsolete TDZ fix script (no longer needed)
- Updated all import paths across stores and configuration files

src/database/index.ts

@@ -0,0 +1 @@
+export * as schema from './schemas'

src/database/schemas/crdt.ts

@@ -0,0 +1,50 @@
+import { integer, sqliteTable, text, index } from 'drizzle-orm/sqlite-core'
+import tableNames from '~/database/tableNames.json'
+
+export const haexCrdtLogs = sqliteTable(
+  tableNames.haex.crdt.logs.name,
+  {
+    id: text()
+      .$defaultFn(() => crypto.randomUUID())
+      .primaryKey(),
+    haexTimestamp: text(tableNames.haex.crdt.logs.columns.haexTimestamp),
+    tableName: text(tableNames.haex.crdt.logs.columns.tableName),
+    rowPks: text(tableNames.haex.crdt.logs.columns.rowPks, { mode: 'json' }),
+    opType: text(tableNames.haex.crdt.logs.columns.opType, {
+      enum: ['INSERT', 'UPDATE', 'DELETE'],
+    }),
+    columnName: text(tableNames.haex.crdt.logs.columns.columnName),
+    newValue: text(tableNames.haex.crdt.logs.columns.newValue, {
+      mode: 'json',
+    }),
+    oldValue: text(tableNames.haex.crdt.logs.columns.oldValue, {
+      mode: 'json',
+    }),
+  },
+  (table) => [
+    index('idx_haex_timestamp').on(table.haexTimestamp),
+    index('idx_table_row').on(table.tableName, table.rowPks),
+  ],
+)
+export type InsertHaexCrdtLogs = typeof haexCrdtLogs.$inferInsert
+export type SelectHaexCrdtLogs = typeof haexCrdtLogs.$inferSelect
+
+export const haexCrdtSnapshots = sqliteTable(
+  tableNames.haex.crdt.snapshots.name,
+  {
+    snapshotId: text(tableNames.haex.crdt.snapshots.columns.snapshotId)
+      .$defaultFn(() => crypto.randomUUID())
+      .primaryKey(),
+    created: text(),
+    epochHlc: text(tableNames.haex.crdt.snapshots.columns.epochHlc),
+    locationUrl: text(tableNames.haex.crdt.snapshots.columns.locationUrl),
+    fileSizeBytes: integer(
+      tableNames.haex.crdt.snapshots.columns.fileSizeBytes,
+    ),
+  },
+)
+
+export const haexCrdtConfigs = sqliteTable(tableNames.haex.crdt.configs.name, {
+  key: text().primaryKey(),
+  value: text(),
+})

src/database/schemas/haex.ts

@@ -0,0 +1,181 @@
+import { sql } from 'drizzle-orm'
+import {
+  check,
+  integer,
+  sqliteTable,
+  text,
+  unique,
+  type AnySQLiteColumn,
+  type SQLiteColumnBuilderBase,
+} from 'drizzle-orm/sqlite-core'
+import tableNames from '~/database/tableNames.json'
+
+const crdtColumnNames = {
+  haexTimestamp: 'haex_timestamp',
+}
+
+// Helper function to add common CRDT columns ( haexTimestamp)
+export const withCrdtColumns = <
+  T extends Record<string, SQLiteColumnBuilderBase>,
+>(
+  columns: T,
+) => ({
+  ...columns,
+  haexTimestamp: text(crdtColumnNames.haexTimestamp),
+})
+
+export const haexSettings = sqliteTable(
+  tableNames.haex.settings.name,
+  withCrdtColumns({
+    id: text()
+      .$defaultFn(() => crypto.randomUUID())
+      .primaryKey(),
+    key: text(),
+    type: text(),
+    value: text(),
+  }),
+  (table) => [unique().on(table.key, table.type, table.value)],
+)
+export type InsertHaexSettings = typeof haexSettings.$inferInsert
+export type SelectHaexSettings = typeof haexSettings.$inferSelect
+
+export const haexExtensions = sqliteTable(
+  tableNames.haex.extensions.name,
+  withCrdtColumns({
+    id: text()
+      .$defaultFn(() => crypto.randomUUID())
+      .primaryKey(),
+    public_key: text().notNull(),
+    name: text().notNull(),
+    version: text().notNull(),
+    author: text(),
+    description: text(),
+    entry: text().default('index.html'),
+    homepage: text(),
+    enabled: integer({ mode: 'boolean' }).default(true),
+    icon: text(),
+    signature: text().notNull(),
+    single_instance: integer({ mode: 'boolean' }).default(false),
+  }),
+  (table) => [
+    // UNIQUE constraint: Pro Developer (public_key) kann nur eine Extension mit diesem Namen existieren
+    unique().on(table.public_key, table.name),
+  ],
+)
+export type InsertHaexExtensions = typeof haexExtensions.$inferInsert
+export type SelectHaexExtensions = typeof haexExtensions.$inferSelect
+
+export const haexExtensionPermissions = sqliteTable(
+  tableNames.haex.extension_permissions.name,
+  withCrdtColumns({
+    id: text()
+      .$defaultFn(() => crypto.randomUUID())
+      .primaryKey(),
+    extensionId: text(tableNames.haex.extension_permissions.columns.extensionId)
+      .notNull()
+      .references((): AnySQLiteColumn => haexExtensions.id, {
+        onDelete: 'cascade',
+      }),
+    resourceType: text('resource_type', {
+      enum: ['fs', 'http', 'db', 'shell'],
+    }),
+    action: text({ enum: ['read', 'write'] }),
+    target: text(),
+    constraints: text({ mode: 'json' }),
+    status: text({ enum: ['ask', 'granted', 'denied'] })
+      .notNull()
+      .default('denied'),
+    createdAt: text('created_at').default(sql`(CURRENT_TIMESTAMP)`),
+    updateAt: integer('updated_at', { mode: 'timestamp' }).$onUpdate(
+      () => new Date(),
+    ),
+  }),
+  (table) => [
+    unique().on(
+      table.extensionId,
+      table.resourceType,
+      table.action,
+      table.target,
+    ),
+  ],
+)
+export type InserthaexExtensionPermissions =
+  typeof haexExtensionPermissions.$inferInsert
+export type SelecthaexExtensionPermissions =
+  typeof haexExtensionPermissions.$inferSelect
+
+export const haexNotifications = sqliteTable(
+  tableNames.haex.notifications.name,
+  withCrdtColumns({
+    id: text()
+      .$defaultFn(() => crypto.randomUUID())
+      .primaryKey(),
+    alt: text(),
+    date: text(),
+    icon: text(),
+    image: text(),
+    read: integer({ mode: 'boolean' }),
+    source: text(),
+    text: text(),
+    title: text(),
+    type: text({
+      enum: ['error', 'success', 'warning', 'info', 'log'],
+    }).notNull(),
+  }),
+)
+export type InsertHaexNotifications = typeof haexNotifications.$inferInsert
+export type SelectHaexNotifications = typeof haexNotifications.$inferSelect
+
+export const haexWorkspaces = sqliteTable(
+  tableNames.haex.workspaces.name,
+  withCrdtColumns({
+    id: text(tableNames.haex.workspaces.columns.id)
+      .$defaultFn(() => crypto.randomUUID())
+      .primaryKey(),
+    deviceId: text(tableNames.haex.workspaces.columns.deviceId).notNull(),
+    name: text(tableNames.haex.workspaces.columns.name).notNull(),
+    position: integer(tableNames.haex.workspaces.columns.position)
+      .notNull()
+      .default(0),
+  }),
+  (table) => [unique().on(table.position)],
+)
+export type InsertHaexWorkspaces = typeof haexWorkspaces.$inferInsert
+export type SelectHaexWorkspaces = typeof haexWorkspaces.$inferSelect
+
+export const haexDesktopItems = sqliteTable(
+  tableNames.haex.desktop_items.name,
+  withCrdtColumns({
+    id: text(tableNames.haex.desktop_items.columns.id)
+      .$defaultFn(() => crypto.randomUUID())
+      .primaryKey(),
+    workspaceId: text(tableNames.haex.desktop_items.columns.workspaceId)
+      .notNull()
+      .references(() => haexWorkspaces.id, { onDelete: 'cascade' }),
+    itemType: text(tableNames.haex.desktop_items.columns.itemType, {
+      enum: ['system', 'extension', 'file', 'folder'],
+    }).notNull(),
+    // Für Extensions (wenn itemType = 'extension')
+    extensionId: text(
+      tableNames.haex.desktop_items.columns.extensionId,
+    ).references((): AnySQLiteColumn => haexExtensions.id, {
+      onDelete: 'cascade',
+    }),
+    // Für System Windows (wenn itemType = 'system')
+    systemWindowId: text(tableNames.haex.desktop_items.columns.systemWindowId),
+    positionX: integer(tableNames.haex.desktop_items.columns.positionX)
+      .notNull()
+      .default(0),
+    positionY: integer(tableNames.haex.desktop_items.columns.positionY)
+      .notNull()
+      .default(0),
+  }),
+  (table) => [
+    check(
+      'item_reference',
+      sql`(${table.itemType} = 'extension' AND ${table.extensionId} IS NOT NULL AND ${table.systemWindowId} IS NULL) OR (${table.itemType} = 'system' AND ${table.systemWindowId} IS NOT NULL AND ${table.extensionId} IS NULL) OR (${table.itemType} = 'file' AND ${table.systemWindowId} IS NOT NULL AND ${table.extensionId} IS NULL) OR (${table.itemType} = 'folder' AND ${table.systemWindowId} IS NOT NULL AND ${table.extensionId} IS NULL)`,
+    ),
+  ],
+)
+export type InsertHaexDesktopItems = typeof haexDesktopItems.$inferInsert
+export type SelectHaexDesktopItems = typeof haexDesktopItems.$inferSelect

src/database/schemas/index.ts

@@ -0,0 +1,2 @@
+export * from './crdt'
+export * from './haex'

src/database/tableNames.json

@@ -0,0 +1,126 @@
+{
+  "haex": {
+    "settings": {
+      "name": "haex_settings",
+      "columns": {
+        "id": "id",
+        "key": "key",
+        "type": "type",
+        "value": "value",
+
+        "haexTimestamp": "haex_timestamp"
+      }
+    },
+    "extensions": {
+      "name": "haex_extensions",
+      "columns": {
+        "id": "id",
+        "author": "author",
+        "description": "description",
+        "entry": "entry",
+        "homepage": "homepage",
+        "enabled": "enabled",
+        "icon": "icon",
+        "name": "name",
+        "public_key": "public_key",
+        "signature": "signature",
+        "url": "url",
+        "version": "version",
+
+        "haexTimestamp": "haex_timestamp"
+      }
+    },
+    "extension_permissions": {
+      "name": "haex_extension_permissions",
+      "columns": {
+        "id": "id",
+        "extensionId": "extension_id",
+        "resourceType": "resource_type",
+        "action": "action",
+        "target": "target",
+        "constraints": "constraints",
+        "status": "status",
+        "createdAt": "created_at",
+        "updateAt": "updated_at",
+
+        "haexTimestamp": "haex_timestamp"
+      }
+    },
+    "notifications": {
+      "name": "haex_notifications",
+      "columns": {
+        "id": "id",
+        "alt": "alt",
+        "date": "date",
+        "icon": "icon",
+        "image": "image",
+        "read": "read",
+        "source": "source",
+        "text": "text",
+        "title": "title",
+        "type": "type",
+
+        "haexTimestamp": "haex_timestamp"
+      }
+    },
+    "workspaces": {
+      "name": "haex_workspaces",
+      "columns": {
+        "id": "id",
+        "deviceId": "device_id",
+        "name": "name",
+        "position": "position",
+        "createdAt": "created_at",
+
+        "haexTimestamp": "haex_timestamp"
+      }
+    },
+    "desktop_items": {
+      "name": "haex_desktop_items",
+      "columns": {
+        "id": "id",
+        "workspaceId": "workspace_id",
+        "itemType": "item_type",
+        "extensionId": "extension_id",
+        "systemWindowId": "system_window_id",
+        "positionX": "position_x",
+        "positionY": "position_y",
+
+        "haexTimestamp": "haex_timestamp"
+      }
+    },
+
+    "crdt": {
+      "logs": {
+        "name": "haex_crdt_logs",
+        "columns": {
+          "id": "id",
+          "haexTimestamp": "haex_timestamp",
+          "tableName": "table_name",
+          "rowPks": "row_pks",
+          "opType": "op_type",
+          "columnName": "column_name",
+          "newValue": "new_value",
+          "oldValue": "old_value"
+        }
+      },
+      "snapshots": {
+        "name": "haex_crdt_snapshots",
+        "columns": {
+          "snapshotId": "snapshot_id",
+          "created": "created",
+          "epochHlc": "epoch_hlc",
+          "locationUrl": "location_url",
+          "fileSizeBytes": "file_size_bytes"
+        }
+      },
+      "configs": {
+        "name": "haex_crdt_configs",
+        "columns": {
+          "key": "key",
+          "value": "value"
+        }
+      }
+    }
+  }
+}

src/stores/desktop/index.ts

@@ -1,9 +1,9 @@
 import { eq } from 'drizzle-orm'
-import { haexDesktopItems } from '~~/src-tauri/database/schemas'
+import { haexDesktopItems } from '~/database/schemas'
 import type {
   InsertHaexDesktopItems,
   SelectHaexDesktopItems,
-} from '~~/src-tauri/database/schemas'
+} from '~/database/schemas'
 import de from './de.json'
 import en from './en.json'
 

src/stores/desktop/workspace.ts

@@ -2,7 +2,7 @@ import { asc, eq } from 'drizzle-orm'
 import {
   haexWorkspaces,
   type SelectHaexWorkspaces,
-} from '~~/src-tauri/database/schemas'
+} from '~/database/schemas'
 import type { Swiper } from 'swiper/types'
 
 export type IWorkspace = SelectHaexWorkspaces

src/stores/vault/index.ts

@@ -2,7 +2,7 @@
 
 import { drizzle } from 'drizzle-orm/sqlite-proxy'
 import { invoke } from '@tauri-apps/api/core'
-import { schema } from '@/../src-tauri/database/index'
+import { schema } from '~/database'
 import type {
   AsyncRemoteCallback,
   SqliteRemoteDatabase,
@@ -21,11 +21,12 @@ export const useVaultStore = defineStore('vaultStore', () => {
     public: { haexVault },
   } = useRuntimeConfig()
 
+  const router = useRouter()
   const currentVaultId = computed<string | undefined>({
     get: () =>
-      getSingleRouteParam(useRouter().currentRoute.value.params.vaultId),
+      getSingleRouteParam(router.currentRoute.value.params.vaultId),
     set: (newVaultId) => {
-      useRouter().currentRoute.value.params.vaultId = newVaultId ?? ''
+      router.currentRoute.value.params.vaultId = newVaultId ?? ''
     },
   })
 

src/stores/vault/notifications.ts

@@ -2,7 +2,7 @@ import { and, eq, or, type SQLWrapper } from 'drizzle-orm'
 import {
   haexNotifications,
   type InsertHaexNotifications,
-} from '~~/src-tauri/database/schemas/haex'
+} from '~/database/schemas/haex'
 import {
   isPermissionGranted,
   requestPermission,
@@ -31,7 +31,12 @@ export const useNotificationStore = defineStore('notificationStore', () => {
   }
 
   const checkNotificationAsync = async () => {
-    isNotificationAllowed.value = await isPermissionGranted()
+    try {
+      isNotificationAllowed.value = await isPermissionGranted()
+    } catch (error) {
+      console.warn('Notification permission check failed:', error)
+      isNotificationAllowed.value = false
+    }
     return isNotificationAllowed.value
   }
 

src/stores/vault/settings.ts

@@ -1,6 +1,6 @@
 import { and, eq } from 'drizzle-orm'
 import { z } from 'zod'
-import * as schema from '@/../src-tauri/database/schemas/haex'
+import * as schema from '~/database/schemas/haex'
 import type { Locale } from 'vue-i18n'
 
 export enum VaultSettingsTypeEnum {