updates

Author: letstri

apps/api/orpc/routers/connections-resources/create.ts

@@ -15,7 +15,7 @@ export const create = orpc
     schema.array(),
   ).pipe(data => Array.isArray(data) ? data : [data]))
   .handler(async ({ context, input }) => {
-    const connectionIds = [...new Set(input.map(item => item.connectionId))]
+    const connectionIds = input.map(item => item.connectionId)
     const foundConnections = await db.select({ id: connections.id })
       .from(connections)
       .where(and(inArray(connections.id, connectionIds), eq(connections.userId, context.user.id)))

apps/app/src/entities/connection/dialects/index.ts

@@ -8,7 +8,6 @@ import type { Database as PostgresDatabase } from './postgres/schema'
 import { PORTS } from '@conar/shared/ports'
 import { Kysely } from 'kysely'
 import { memoize } from 'memoza'
-import { connectionStringStorage } from '~/lib/connection-string-storage'
 import { createProxyClient, orpcProxy } from '~/lib/orpc'
 import { getConnectionStore } from '../store'
 import { connectionsCollection, connectionsResourcesCollection } from '../sync'
@@ -19,7 +18,7 @@ import { mysqlColdDialect, mysqlDialect } from './mysql'
 import { postgresColdDialect, postgresDialect } from './postgres'
 
 export interface DialectOptions {
-  connectionString?: string
+  connectionString: string
   connectionId?: string
   resourceId?: string
   log?: (params: {
@@ -37,21 +36,7 @@ function resolveProxyIdParams(options: DialectOptions) {
     return { resourceId: options.resourceId }
   if (options.connectionId)
     return { connectionId: options.connectionId }
-  return { connectionString: options.connectionString! }
-}
-
-async function resolveElectronConnectionString(options: DialectOptions, connectionId: string | undefined): Promise<string> {
-  if (options.connectionString) {
-    return options.connectionString
-  }
-
-  if (connectionId) {
-    if (connectionStringStorage.has(connectionId)) {
-      return connectionStringStorage.decrypt(connectionId)
-    }
-  }
-
-  throw new Error('No connection string available for this connection')
+  return { connectionString: options.connectionString }
 }
 
 interface QueryPayload {
@@ -88,20 +73,16 @@ export function createDialectProvider(type: ConnectionType, options: DialectOpti
   }
 
   return {
-    async execute(payload: QueryPayload) {
+    execute(payload: QueryPayload) {
       const t = resolveTransport()
-      if (t.kind === 'electron') {
-        const connectionString = await resolveElectronConnectionString(options, connectionId)
-        return t.electron.execute({ connectionString, ...payload })
-      }
+      if (t.kind === 'electron')
+        return t.electron.execute({ connectionString: options.connectionString, ...payload })
       return t.proxy.execute({ ...resolveProxyIdParams(options), ...payload })
     },
-    async beginTransaction() {
+    beginTransaction() {
       const t = resolveTransport()
-      if (t.kind === 'electron') {
-        const connectionString = await resolveElectronConnectionString(options, connectionId)
-        return t.electron.beginTransaction({ connectionString })
-      }
+      if (t.kind === 'electron')
+        return t.electron.beginTransaction({ connectionString: options.connectionString })
       return t.proxy.beginTransaction(resolveProxyIdParams(options))
     },
     executeTransaction(params: TxQueryPayload) {

apps/app/src/entities/connection/hooks/use-fetching-config.ts

@@ -1,6 +1,6 @@
 import type { Connection } from '~/entities/connection/sync'
 import { useSubscription } from 'seitu/react'
-import { useConnectionStringInfo } from '~/lib/connection-string-storage'
+import { useConnectionString } from '~/lib/connection-string-storage'
 import { useLocalProxyAvailable } from '../proxy'
 import { getConnectionStore } from '../store'
 import { fetchingConfig } from '../utils/fetching'
@@ -9,7 +9,7 @@ type Conn = Pick<Connection, 'id' | 'syncType' | 'passwordExists'>
 
 export function useFetchingConfig(connection: Conn) {
   const isLocalProxyAvailable = useLocalProxyAvailable()
-  const info = useConnectionStringInfo(connection.id)
+  const info = useConnectionString(connection.id)
   const proxy = useSubscription(getConnectionStore(connection.id), { selector: s => s.proxy })
 
   return fetchingConfig(connection, {

apps/app/src/entities/connection/queries/columns.ts

@@ -280,6 +280,6 @@ export function resourceTableColumnsQueryOptions({
 }) {
   return queryOptions({
     queryKey: ['connection-resource', connectionResource.id, 'columns', schema, table],
-    queryFn: () => resourceTableColumnsQuery({ table, schema }).run(connectionResourceToQueryParams(connectionResource)),
+    queryFn: async () => resourceTableColumnsQuery({ table, schema }).run(await connectionResourceToQueryParams(connectionResource)),
   })
 }

apps/app/src/entities/connection/queries/connection-resources.ts

@@ -43,7 +43,7 @@ export const connectionResourcesQuery = createQuery({
 export function connectionResourcesQueryOptions(connection: Connection) {
   return queryOptions({
     queryKey: ['connection', connection.id, 'resources'],
-    queryFn: () => connectionResourcesQuery.run(connectionToQueryParams(connection)),
+    queryFn: async () => connectionResourcesQuery.run(await connectionToQueryParams(connection)),
     throwOnError: false,
   })
 }

apps/app/src/entities/connection/queries/connection-version.ts

@@ -67,7 +67,7 @@ export const connectionVersionQuery = createQuery({
 export function connectionVersionQueryOptions(connection: Connection) {
   return queryOptions({
     queryKey: ['connection-resource', connection.id, 'version'],
-    queryFn: () => connectionVersionQuery.run(connectionToQueryParams(connection)),
+    queryFn: async () => connectionVersionQuery.run(await connectionToQueryParams(connection)),
     throwOnError: false,
   })
 }

apps/app/src/entities/connection/queries/constraints.ts

@@ -152,7 +152,7 @@ export const resourceConstraintsQuery = createQuery({
 
 export function resourceConstraintsQueryOptions({ connectionResource }: { connectionResource: ConnectionResource }) {
   return queryOptions({
-    queryFn: () => resourceConstraintsQuery.run(connectionResourceToQueryParams(connectionResource)),
+    queryFn: async () => resourceConstraintsQuery.run(await connectionResourceToQueryParams(connectionResource)),
     queryKey: ['connection-resource', connectionResource.id, 'constraints'],
   })
 }

apps/app/src/entities/connection/queries/enums.ts

@@ -214,6 +214,6 @@ export const resourceEnumsQuery = createQuery({
 export function resourceEnumsQueryOptions({ connectionResource }: { connectionResource: ConnectionResource }) {
   return queryOptions({
     queryKey: ['connection-resource', connectionResource.id, 'enums'],
-    queryFn: () => resourceEnumsQuery.run(connectionResourceToQueryParams(connectionResource)),
+    queryFn: async () => resourceEnumsQuery.run(await connectionResourceToQueryParams(connectionResource)),
   })
 }

apps/app/src/entities/connection/queries/functions.ts

@@ -125,7 +125,7 @@ export const resourceFunctionsQuery = createQuery({
 
 export function resourceFunctionsQueryOptions({ connectionResource }: { connectionResource: ConnectionResource }) {
   return queryOptions({
-    queryFn: () => resourceFunctionsQuery.run(connectionResourceToQueryParams(connectionResource)),
+    queryFn: async () => resourceFunctionsQuery.run(await connectionResourceToQueryParams(connectionResource)),
     queryKey: ['connection-resource', connectionResource.id, 'functions'],
   })
 }

apps/app/src/entities/connection/queries/indexes.ts

@@ -126,6 +126,6 @@ export const resourceIndexesQuery = createQuery({
 export function resourceIndexesQueryOptions({ connectionResource }: { connectionResource: ConnectionResource }) {
   return queryOptions({
     queryKey: ['connection-resource', connectionResource.id, 'indexes'],
-    queryFn: () => resourceIndexesQuery.run(connectionResourceToQueryParams(connectionResource)),
+    queryFn: async () => resourceIndexesQuery.run(await connectionResourceToQueryParams(connectionResource)),
   })
 }