openAgent

1/* oxlint-disable */
2import { Column, getColumnTable } from "drizzle-orm/column"
3import { is } from "drizzle-orm/entity"
4import type { JoinNullability } from "drizzle-orm/query-builders/select.types"
5import { Param, SQL } from "drizzle-orm/sql/sql"
6import type { SelectedFieldsOrdered } from "drizzle-orm/sqlite-core/query-builders/select.types"
7import type { SQLiteUpdateSetSource } from "drizzle-orm/sqlite-core/query-builders/update"
8import type { SQLiteTable } from "drizzle-orm/sqlite-core/table"
9import { SQLiteViewBase } from "drizzle-orm/sqlite-core/view-base"
10import { Subquery } from "drizzle-orm/subquery"
11import { Table, getTableName } from "drizzle-orm/table"
12import type { UpdateSet } from "drizzle-orm/utils"
13import { ViewBaseConfig } from "drizzle-orm/view-common"
14 
15const TableSymbol = (
16  Table as unknown as {
17    Symbol: { Columns: symbol; IsAlias: symbol; Name: symbol; BaseName: symbol }
18  }
19).Symbol
20 
21export function getTableColumnsRuntime(table: SQLiteTable) {
22  return (table as unknown as Record<symbol, Record<string, Column>>)[TableSymbol.Columns]
23}
24 
25export function getViewSelectedFieldsRuntime(view: SQLiteViewBase) {
26  return (view as unknown as Record<symbol, { selectedFields: Record<string, unknown>; name: string }>)[ViewBaseConfig]
27}
28 
29export function jitCompatCheck(isEnabled: boolean | undefined) {
30  if (!isEnabled) return false
31  try {
32    return new Function("input", '"use strict"; return input;')(true) === true
33  } catch {
34    return false
35  }
36}
37 
38export function orderSelectedFields<TColumn extends Column>(
39  fields: Record<string, unknown>,
40  pathPrefix?: string[],
41): SelectedFieldsOrdered {
42  return Object.entries(fields).flatMap(([name, field]) => {
43    const path = pathPrefix ? [...pathPrefix, name] : [name]
44    if (is(field, Column) || is(field, SQL) || is(field, SQL.Aliased) || is(field, Subquery)) {
45      return [{ path, field }] as SelectedFieldsOrdered
46    }
47    if (is(field, Table)) return orderSelectedFields(getTableColumnsRuntime(field as SQLiteTable), path)
48    return orderSelectedFields(field as Record<string, unknown>, path)
49  }) as SelectedFieldsOrdered
50}
51 
52export function mapUpdateSet<TTable extends SQLiteTable>(table: TTable, values: SQLiteUpdateSetSource<TTable>) {
53  const entries = Object.entries(values).filter(([, value]) => value !== undefined)
54  if (entries.length === 0) throw new Error("No values to set")
55 
56  return Object.fromEntries(
57    entries.map(([key, value]) => [
58      key,
59      is(value, SQL) || is(value, Column) ? value : new Param(value, getTableColumnsRuntime(table)[key]),
60    ]),
61  ) as UpdateSet
62}
63 
64export function mapResultRow(
65  columns: SelectedFieldsOrdered,
66  row: unknown[],
67  joinsNotNullableMap: Record<string, boolean> | undefined,
68) {
69  const nullifyMap: Record<string, string | false> = {}
70  const result: Record<string, unknown> = {}
71 
72  columns.forEach((column, columnIndex) => {
73    const decoder = (
74      is(column.field, Column)
75        ? column.field
76        : is(column.field, SQL)
77          ? (column.field as unknown as { decoder: { mapFromDriverValue(value: unknown): unknown } }).decoder
78          : is(column.field, Subquery)
79            ? (column.field._.sql as unknown as { decoder: { mapFromDriverValue(value: unknown): unknown } }).decoder
80            : (column.field.sql as unknown as { decoder: { mapFromDriverValue(value: unknown): unknown } }).decoder
81    ) as {
82      mapFromDriverValue(value: unknown): unknown
83    }
84    const rawValue = row[columnIndex]
85    const value = rawValue === null ? null : decoder.mapFromDriverValue(rawValue)
86    const objectName = column.path[0]
87    let node = result
88 
89    column.path.forEach((pathChunk, pathChunkIndex) => {
90      if (pathChunkIndex === column.path.length - 1) {
91        node[pathChunk] = value
92        return
93      }
94      node[pathChunk] = (node[pathChunk] ?? {}) as Record<string, unknown>
95      node = node[pathChunk] as Record<string, unknown>
96    })
97 
98    if (joinsNotNullableMap && is(column.field, Column) && column.path.length === 2 && objectName) {
99      const tableName = getTableName(getColumnTable(column.field))
100      nullifyMap[objectName] =
101        !(objectName in nullifyMap) && value === null
102          ? tableName
103          : typeof nullifyMap[objectName] === "string" && nullifyMap[objectName] !== tableName
104            ? false
105            : nullifyMap[objectName]
106    }
107  })
108 
109  Object.entries(nullifyMap).forEach(([objectName, tableName]) => {
110    if (typeof tableName === "string" && !joinsNotNullableMap?.[tableName]) result[objectName] = null
111  })
112 
113  return result
114}
115 
116export function getTableLikeName(table: SQLiteTable | Subquery | SQLiteViewBase | SQL) {
117  if (is(table, Subquery)) return table._.alias
118  if (is(table, SQLiteViewBase)) return getViewSelectedFieldsRuntime(table).name
119  if (is(table, SQL)) return undefined
120  return (table as unknown as Record<symbol, string | boolean>)[
121    (table as unknown as Record<symbol, string | boolean>)[TableSymbol.IsAlias]
122      ? TableSymbol.Name
123      : TableSymbol.BaseName
124  ] as string
125}
126 
127export type { JoinNullability }
128