feat(schema): adds table schema & query copy (#275)

Co-authored-by: Valerii Strilets <valerii.strilets@gmail.com>

Author: Rudra-Sankha-Sinhamahapatra

apps/desktop/package.json

@@ -81,6 +81,7 @@
     "arktype": "catalog:",
     "babel-plugin-react-compiler": "catalog:",
     "better-auth": "catalog:",
+    "change-case": "catalog:",
     "date-fns": "catalog:",
     "drizzle-kit": "catalog:",
     "drizzle-orm": "catalog:",

apps/desktop/src/components/sidebar-link.tsx

@@ -3,17 +3,29 @@ import type { ComponentProps } from 'react'
 import { cn } from '@conar/ui/lib/utils'
 import { Link } from '@tanstack/react-router'
 
+const baseClasses = 'flex w-full items-center gap-2 rounded-md border px-2 py-1 text-sm'
+const activeClasses = 'border-primary/20 bg-primary/10 text-primary hover:bg-primary/20'
+const inactiveClasses = 'border-transparent text-foreground hover:bg-accent/30'
+
+export function SidebarButton({ className, active, ...props }: ComponentProps<'button'> & { active?: boolean }) {
+  return (
+    <button
+      type="button"
+      className={cn(baseClasses, className, active ? activeClasses : inactiveClasses)}
+      {...props}
+    />
+  )
+}
+
 export function SidebarLink({
   className,
   ...props
 }: LinkProps & Omit<ComponentProps<'a'>, 'children'>) {
   return (
     <Link
-      activeProps={{ className: 'border-primary/20 bg-primary/10 text-primary hover:bg-primary/20' }}
-      inactiveProps={{ className: 'border-transparent text-foreground hover:bg-accent/30' }}
-      className={cn(`
-        flex w-full items-center gap-2 rounded-md border px-2 py-1 text-sm
-      `, className)}
+      activeProps={{ className: activeClasses }}
+      inactiveProps={{ className: inactiveClasses }}
+      className={cn(baseClasses, className)}
       {...props}
     />
   )

apps/desktop/src/entities/connection/components/table/table-cell-table.tsx

@@ -66,7 +66,6 @@ export function TableCellTable({ schema, table, column, value }: { schema: strin
         header: props => (
           <TableHeaderCell
             column={column}
-            resize={false}
             {...props}
           />
         ),

apps/desktop/src/entities/connection/components/table/utils.ts

@@ -1,23 +1,31 @@
 export interface Column {
   id: string
-  type?: string
+  type: string
+  label?: string
   enum?: string
   isArray?: boolean
   isEditable?: boolean
   isNullable?: boolean
+  maxLength?: number | null
+  precision?: number | null
+  scale?: number | null
   unique?: string
   primaryKey?: string
+  defaultValue?: string | null
   foreign?: {
     name: string
     schema: string
     table: string
     column: string
+    onDelete?: string
+    onUpdate?: string
   }
   references?: {
     name: string
     schema: string
     table: string
     column: string
+    isUnique?: boolean
   }[]
 }
 

apps/desktop/src/entities/connection/dialects/clickhouse/index.ts

@@ -1,7 +1,7 @@
 import type { CompiledQuery, Dialect, Driver, QueryResult } from 'kysely'
 import type { connections } from '~/drizzle'
 import { type } from 'arktype'
-import { MysqlQueryCompiler } from 'kysely'
+import { DummyDriver, MysqlQueryCompiler } from 'kysely'
 import { logSql } from '../../sql'
 
 function escapeSqlString(v: string) {
@@ -86,19 +86,34 @@ function createDriver(connection: typeof connections.$inferSelect) {
   } satisfies Driver
 }
 
+function clickhouseAdapter() {
+  return {
+    supportsCreateIfNotExists: false,
+    supportsTransactionalDdl: false,
+    supportsReturning: false,
+    acquireMigrationLock: async () => {},
+    releaseMigrationLock: async () => {},
+  }
+}
+
 export function clickhouseDialect(connection: typeof connections.$inferSelect) {
   return {
-    createAdapter: () => ({
-      supportsCreateIfNotExists: false,
-      supportsTransactionalDdl: false,
-      supportsReturning: false,
-      acquireMigrationLock: async () => {},
-      releaseMigrationLock: async () => {},
-    }),
+    createAdapter: clickhouseAdapter,
     createDriver: () => createDriver(connection),
     createQueryCompiler: () => new MysqlQueryCompiler(),
     createIntrospector: () => {
       throw new Error('Not implemented')
     },
   } satisfies Dialect
 }
+
+export function clickhouseColdDialect() {
+  return {
+    createAdapter: clickhouseAdapter,
+    createDriver: () => new DummyDriver(),
+    createQueryCompiler: () => new MysqlQueryCompiler(),
+    createIntrospector: () => {
+      throw new Error('Not implemented')
+    },
+  } satisfies Dialect
+}

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

@@ -6,14 +6,25 @@ import type { Database as PostgresDatabase } from './postgres/schema'
 import type { connections } from '~/drizzle'
 import { memoize } from '@conar/shared/utils/helpers'
 import { Kysely } from 'kysely'
-import { clickhouseDialect } from './clickhouse'
-import { mssqlDialect } from './mssql'
-import { mysqlDialect } from './mysql'
-import { postgresDialect } from './postgres'
+import { clickhouseColdDialect, clickhouseDialect } from './clickhouse'
+import { mssqlColdDialect, mssqlDialect } from './mssql'
+import { mysqlColdDialect, mysqlDialect } from './mysql'
+import { postgresColdDialect, postgresDialect } from './postgres'
+
+const coldDialects = {
+  postgres: postgresColdDialect,
+  mysql: mysqlColdDialect,
+  clickhouse: clickhouseColdDialect,
+  mssql: mssqlColdDialect,
+} satisfies Record<ConnectionType, () => unknown>
 
 export const dialects = {
   postgres: memoize((connection: typeof connections.$inferSelect) => new Kysely<PostgresDatabase>({ dialect: postgresDialect(connection) })),
   mysql: memoize((connection: typeof connections.$inferSelect) => new Kysely<MysqlDatabase>({ dialect: mysqlDialect(connection) })),
   clickhouse: memoize((connection: typeof connections.$inferSelect) => new Kysely<ClickhouseDatabase>({ dialect: clickhouseDialect(connection) })),
   mssql: memoize((connection: typeof connections.$inferSelect) => new Kysely<MssqlDatabase>({ dialect: mssqlDialect(connection) })),
 } satisfies Record<ConnectionType, (connection: typeof connections.$inferSelect) => unknown>
+
+export function getColdDialect(dialect: ConnectionType) {
+  return new Kysely<Record<string, Record<string, unknown>>>({ dialect: coldDialects[dialect]() })
+}

apps/desktop/src/entities/connection/dialects/mssql/index.ts

@@ -9,7 +9,7 @@ import type {
   SelectQueryNode,
 } from 'kysely'
 import type { connections } from '~/drizzle'
-import { MssqlQueryCompiler as DefaultMssqlQueryCompiler, MssqlAdapter } from 'kysely'
+import { MssqlQueryCompiler as DefaultMssqlQueryCompiler, DummyDriver, MssqlAdapter } from 'kysely'
 import { logSql } from '../../sql'
 
 function isSelectQueryNode(node: OperationNode): node is SelectQueryNode {
@@ -98,3 +98,14 @@ export function mssqlDialect(connection: typeof connections.$inferSelect) {
     },
   } satisfies Dialect
 }
+
+export function mssqlColdDialect() {
+  return {
+    createDriver: () => new DummyDriver(),
+    createQueryCompiler: () => new MssqlQueryCompiler(),
+    createAdapter: () => new MssqlAdapter(),
+    createIntrospector: () => {
+      throw new Error('Not implemented')
+    },
+  } satisfies Dialect
+}

apps/desktop/src/entities/connection/dialects/mysql/index.ts

@@ -1,6 +1,6 @@
 import type { CompiledQuery, Dialect, Driver, QueryResult } from 'kysely'
 import type { connections } from '~/drizzle'
-import { MysqlAdapter, MysqlQueryCompiler } from 'kysely'
+import { DummyDriver, MysqlAdapter, MysqlQueryCompiler } from 'kysely'
 import { logSql } from '../../sql'
 
 function execute(connection: typeof connections.$inferSelect, compiledQuery: CompiledQuery) {
@@ -57,3 +57,14 @@ export function mysqlDialect(connection: typeof connections.$inferSelect) {
     },
   } satisfies Dialect
 }
+
+export function mysqlColdDialect() {
+  return {
+    createDriver: () => new DummyDriver(),
+    createQueryCompiler: () => new MysqlQueryCompiler(),
+    createAdapter: () => new MysqlAdapter(),
+    createIntrospector: () => {
+      throw new Error('Not implemented')
+    },
+  } satisfies Dialect
+}

apps/desktop/src/entities/connection/dialects/mysql/schema/information.ts

@@ -9,6 +9,7 @@ export interface InformationSchema {
   TABLE_CONSTRAINTS: TableConstraints
   KEY_COLUMN_USAGE: KeyColumnUsage
   STATISTICS: Statistics
+  REFERENTIAL_CONSTRAINTS: ReferentialConstraints
 }
 
 /**
@@ -129,3 +130,21 @@ interface Statistics {
   COLUMN_NAME: string
   NON_UNIQUE: number
 }
+
+/**
+ * @name REFERENTIAL_CONSTRAINTS
+ * @type table
+ */
+interface ReferentialConstraints {
+  CONSTRAINT_CATALOG: string
+  CONSTRAINT_SCHEMA: string
+  CONSTRAINT_NAME: string
+  UNIQUE_CONSTRAINT_CATALOG: string
+  UNIQUE_CONSTRAINT_SCHEMA: string
+  UNIQUE_CONSTRAINT_NAME: string
+  MATCH_OPTION: string
+  UPDATE_RULE: string
+  DELETE_RULE: string
+  TABLE_NAME: string
+  REFERENCED_TABLE_NAME: string
+}

apps/desktop/src/entities/connection/dialects/postgres/index.ts

@@ -1,6 +1,6 @@
 import type { CompiledQuery, Dialect, Driver, QueryResult } from 'kysely'
 import type { connections } from '~/drizzle'
-import { PostgresAdapter, PostgresQueryCompiler } from 'kysely'
+import { DummyDriver, PostgresAdapter, PostgresQueryCompiler } from 'kysely'
 import { logSql } from '../../sql'
 
 function execute(connection: typeof connections.$inferSelect, compiledQuery: CompiledQuery) {
@@ -57,3 +57,14 @@ export function postgresDialect(connection: typeof connections.$inferSelect) {
     },
   } satisfies Dialect
 }
+
+export function postgresColdDialect() {
+  return {
+    createDriver: () => new DummyDriver(),
+    createQueryCompiler: () => new PostgresQueryCompiler(),
+    createAdapter: () => new PostgresAdapter(),
+    createIntrospector: () => {
+      throw new Error('Not implemented')
+    },
+  } satisfies Dialect
+}