eslint-plugin-slonik 1.0.0

package/dist/workers/check-sql.worker.cjs

@@ -0,0 +1,2436 @@
+'use strict';
+
+const checkSql_utils = require('../shared/eslint-plugin-slonik.rlOTrCdf.cjs');
+const fpTs = require('fp-ts');
+const parser = require('libpg-query');
+const path = require('path');
+const synckit = require('synckit');
+const tsPattern = require('ts-pattern');
+const postgres = require('postgres');
+require('fp-ts/lib/Either.js');
+const function_js = require('fp-ts/lib/function.js');
+const O = require('fp-ts/lib/Option.js');
+const TE = require('fp-ts/lib/TaskEither.js');
+const J = require('fp-ts/lib/Json.js');
+const chokidar = require('chokidar');
+require('crypto');
+require('fs');
+require('@typescript-eslint/utils');
+require('pg-connection-string');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+function _interopNamespaceCompat(e) {
+  if (e && typeof e === 'object' && 'default' in e) return e;
+  const n = Object.create(null);
+  if (e) {
+    for (const k in e) {
+      n[k] = e[k];
+    }
+  }
+  n.default = e;
+  return n;
+}
+
+const parser__namespace = /*#__PURE__*/_interopNamespaceCompat(parser);
+const path__default = /*#__PURE__*/_interopDefaultCompat(path);
+const postgres__default = /*#__PURE__*/_interopDefaultCompat(postgres);
+const O__namespace = /*#__PURE__*/_interopNamespaceCompat(O);
+const TE__namespace = /*#__PURE__*/_interopNamespaceCompat(TE);
+const J__namespace = /*#__PURE__*/_interopNamespaceCompat(J);
+const chokidar__default = /*#__PURE__*/_interopDefaultCompat(chokidar);
+
+var AExprKind = /* @__PURE__ */ ((AExprKind2) => {
+  AExprKind2["A_EXPR_KIND_UNDEFINED"] = "A_EXPR_KIND_UNDEFINED";
+  AExprKind2["AEXPR_OP"] = "AEXPR_OP";
+  AExprKind2["AEXPR_OP_ANY"] = "AEXPR_OP_ANY";
+  AExprKind2["AEXPR_OP_ALL"] = "AEXPR_OP_ALL";
+  AExprKind2["AEXPR_DISTINCT"] = "AEXPR_DISTINCT";
+  AExprKind2["AEXPR_NOT_DISTINCT"] = "AEXPR_NOT_DISTINCT";
+  AExprKind2["AEXPR_NULLIF"] = "AEXPR_NULLIF";
+  AExprKind2["AEXPR_IN"] = "AEXPR_IN";
+  AExprKind2["AEXPR_LIKE"] = "AEXPR_LIKE";
+  AExprKind2["AEXPR_ILIKE"] = "AEXPR_ILIKE";
+  AExprKind2["AEXPR_SIMILAR"] = "AEXPR_SIMILAR";
+  AExprKind2["AEXPR_BETWEEN"] = "AEXPR_BETWEEN";
+  AExprKind2["AEXPR_NOT_BETWEEN"] = "AEXPR_NOT_BETWEEN";
+  AExprKind2["AEXPR_BETWEEN_SYM"] = "AEXPR_BETWEEN_SYM";
+  AExprKind2["AEXPR_NOT_BETWEEN_SYM"] = "AEXPR_NOT_BETWEEN_SYM";
+  AExprKind2["UNRECOGNIZED"] = "UNRECOGNIZED";
+  return AExprKind2;
+})(AExprKind || {});
+var BoolExprType = /* @__PURE__ */ ((BoolExprType2) => {
+  BoolExprType2["BOOL_EXPR_TYPE_UNDEFINED"] = "BOOL_EXPR_TYPE_UNDEFINED";
+  BoolExprType2["AND_EXPR"] = "AND_EXPR";
+  BoolExprType2["OR_EXPR"] = "OR_EXPR";
+  BoolExprType2["NOT_EXPR"] = "NOT_EXPR";
+  BoolExprType2["UNRECOGNIZED"] = "UNRECOGNIZED";
+  return BoolExprType2;
+})(BoolExprType || {});
+var SubLinkType = /* @__PURE__ */ ((SubLinkType2) => {
+  SubLinkType2["SUB_LINK_TYPE_UNDEFINED"] = "SUB_LINK_TYPE_UNDEFINED";
+  SubLinkType2["EXISTS_SUBLINK"] = "EXISTS_SUBLINK";
+  SubLinkType2["ALL_SUBLINK"] = "ALL_SUBLINK";
+  SubLinkType2["ANY_SUBLINK"] = "ANY_SUBLINK";
+  SubLinkType2["ROWCOMPARE_SUBLINK"] = "ROWCOMPARE_SUBLINK";
+  SubLinkType2["EXPR_SUBLINK"] = "EXPR_SUBLINK";
+  SubLinkType2["MULTIEXPR_SUBLINK"] = "MULTIEXPR_SUBLINK";
+  SubLinkType2["ARRAY_SUBLINK"] = "ARRAY_SUBLINK";
+  SubLinkType2["CTE_SUBLINK"] = "CTE_SUBLINK";
+  SubLinkType2["UNRECOGNIZED"] = "UNRECOGNIZED";
+  return SubLinkType2;
+})(SubLinkType || {});
+var NullTestType = /* @__PURE__ */ ((NullTestType2) => {
+  NullTestType2["NULL_TEST_TYPE_UNDEFINED"] = "NULL_TEST_TYPE_UNDEFINED";
+  NullTestType2["IS_NULL"] = "IS_NULL";
+  NullTestType2["IS_NOT_NULL"] = "IS_NOT_NULL";
+  NullTestType2["UNRECOGNIZED"] = "UNRECOGNIZED";
+  return NullTestType2;
+})(NullTestType || {});
+var JoinType = /* @__PURE__ */ ((JoinType2) => {
+  JoinType2["JOIN_TYPE_UNDEFINED"] = "JOIN_TYPE_UNDEFINED";
+  JoinType2["JOIN_INNER"] = "JOIN_INNER";
+  JoinType2["JOIN_LEFT"] = "JOIN_LEFT";
+  JoinType2["JOIN_FULL"] = "JOIN_FULL";
+  JoinType2["JOIN_RIGHT"] = "JOIN_RIGHT";
+  JoinType2["JOIN_SEMI"] = "JOIN_SEMI";
+  JoinType2["JOIN_ANTI"] = "JOIN_ANTI";
+  JoinType2["JOIN_UNIQUE_OUTER"] = "JOIN_UNIQUE_OUTER";
+  JoinType2["JOIN_UNIQUE_INNER"] = "JOIN_UNIQUE_INNER";
+  JoinType2["UNRECOGNIZED"] = "UNRECOGNIZED";
+  return JoinType2;
+})(JoinType || {});
+
+function isColumnStarRef(fields) {
+  return isSingleCell(fields) && fields[0]?.A_Star !== void 0;
+}
+function isColumnTableStarRef(fields) {
+  return isTuple(fields) && fields[0].String !== void 0 && fields[1].A_Star !== void 0;
+}
+function isColumnUnknownRef(fields) {
+  return isSingleCell(fields) && fields[0].String !== void 0;
+}
+function isColumnTableColumnRef(fields) {
+  return isTuple(fields) && fields[0].String !== void 0 && fields[1].String !== void 0;
+}
+function isSingleCell(arr) {
+  return arr.length === 1;
+}
+function isTuple(arr) {
+  return arr.length === 2;
+}
+
+function getSources({
+  select,
+  prevSources,
+  nonNullableColumns,
+  pgColsBySchemaAndTableName,
+  relations
+}) {
+  const relationsByAlias = /* @__PURE__ */ new Map();
+  const relationsByRelName = /* @__PURE__ */ new Map();
+  for (const rel of relations) {
+    const key = rel.alias ?? rel.joinRelName;
+    if (key) {
+      relationsByAlias.set(key, rel);
+    }
+    if (!relationsByRelName.has(rel.relName)) {
+      relationsByRelName.set(rel.relName, []);
+    }
+    relationsByRelName.get(rel.relName).push(rel);
+  }
+  const tableToSchema = /* @__PURE__ */ new Map();
+  const publicCols = pgColsBySchemaAndTableName.get("public");
+  if (publicCols) {
+    for (const tableName of publicCols.keys()) {
+      tableToSchema.set(tableName, "public");
+    }
+  }
+  for (const [schemaName, cols] of pgColsBySchemaAndTableName) {
+    if (schemaName === "public") break;
+    for (const tableName of cols.keys()) {
+      if (!tableToSchema.has(tableName)) {
+        tableToSchema.set(tableName, schemaName);
+      }
+    }
+  }
+  function getColumnCTEs(ctes2) {
+    const map = /* @__PURE__ */ new Map();
+    for (const cte of ctes2) {
+      if (cte.CommonTableExpr?.ctequery?.SelectStmt === void 0) continue;
+      if (cte.CommonTableExpr?.ctename === void 0) continue;
+      const resolver = getSources({
+        pgColsBySchemaAndTableName,
+        prevSources,
+        nonNullableColumns,
+        relations,
+        select: cte.CommonTableExpr.ctequery.SelectStmt
+      });
+      map.set(cte.CommonTableExpr.ctename, resolver);
+    }
+    return map;
+  }
+  const ctes = getColumnCTEs(select.withClause?.ctes ?? []);
+  function resolveRangeVarSchema(node) {
+    switch (true) {
+      case node.schemaname !== void 0:
+        return node.schemaname;
+      case pgColsBySchemaAndTableName.get("public")?.has(node.relname):
+        return "public";
+      default:
+        for (const [schemaName, cols] of pgColsBySchemaAndTableName) {
+          if (cols.has(node.relname)) {
+            return schemaName;
+          }
+        }
+        return "public";
+    }
+  }
+  function getNodeColumnAndSources(node) {
+    if (node.RangeVar !== void 0) {
+      const cteResolver = ctes.get(node.RangeVar.relname);
+      if (cteResolver !== void 0) {
+        return [{ kind: "cte", name: node.RangeVar.relname, sources: cteResolver }];
+      }
+      const schemaName = resolveRangeVarSchema(node.RangeVar);
+      const realTableName = node.RangeVar.relname;
+      const tableName = node.RangeVar.alias?.aliasname ?? realTableName;
+      const tableColsArray = pgColsBySchemaAndTableName.get(schemaName)?.get(realTableName) ?? [];
+      const tableSource = {
+        kind: "table",
+        schemaName,
+        original: realTableName,
+        name: tableName,
+        alias: node.RangeVar.alias?.aliasname,
+        columns: /* @__PURE__ */ new Map()
+      };
+      for (const col of tableColsArray) {
+        tableSource.columns.set(col.colName, resolveColumn(col, tableSource));
+      }
+      return [tableSource];
+    }
+    const sourcesArr = [];
+    if (node.JoinExpr?.larg !== void 0) {
+      sourcesArr.push(...getNodeColumnAndSources(node.JoinExpr.larg));
+    }
+    if (node.JoinExpr?.rarg !== void 0) {
+      sourcesArr.push(...getNodeColumnAndSources(node.JoinExpr.rarg));
+    }
+    if (node.RangeSubselect?.subquery?.SelectStmt?.fromClause !== void 0) {
+      const combinedPrevSources = new Map([
+        ...prevSources?.entries() ?? [],
+        ...sourcesArr.map((x) => [x.name, x])
+      ]);
+      sourcesArr.push({
+        kind: "subselect",
+        name: node.RangeSubselect.alias?.aliasname ?? "subselect",
+        sources: getSources({
+          nonNullableColumns,
+          pgColsBySchemaAndTableName,
+          relations,
+          prevSources: combinedPrevSources,
+          select: node.RangeSubselect.subquery.SelectStmt
+        })
+      });
+    }
+    return sourcesArr;
+  }
+  function getColumnSources(stmt) {
+    const fromClauseSources = [];
+    for (const node of stmt.fromClause ?? []) {
+      const nodes = getNodeColumnAndSources(node);
+      for (const nodeSource of nodes) {
+        fromClauseSources.push([nodeSource.name, nodeSource]);
+      }
+    }
+    return new Map(fromClauseSources);
+  }
+  const sources = new Map([
+    ...prevSources?.entries() ?? [],
+    ...getColumnSources(select).entries()
+  ]);
+  const cachedColumnsMap = /* @__PURE__ */ new WeakMap();
+  function getSourceColumns(source) {
+    if (cachedColumnsMap.has(source)) {
+      return cachedColumnsMap.get(source);
+    }
+    let result = [];
+    switch (source.kind) {
+      case "table":
+        result = Array.from(source.columns.values()).map((col) => ({
+          column: col,
+          source
+        }));
+        break;
+      case "cte":
+      case "subselect":
+        result = [];
+        break;
+    }
+    cachedColumnsMap.set(source, result);
+    return result;
+  }
+  function getAllResolvedColumns() {
+    const all = [];
+    for (const source of sources.values()) {
+      all.push(...getSourceColumns(source));
+    }
+    return all;
+  }
+  const allResolved = getAllResolvedColumns();
+  const columnIndex = /* @__PURE__ */ new Map();
+  const unknownColumnIndex = /* @__PURE__ */ new Map();
+  for (const entry of allResolved) {
+    const key = `${entry.source.name}.${entry.column.column.colName}`;
+    columnIndex.set(key, entry);
+    const unknownKey = entry.column.column.colName;
+    if (!unknownColumnIndex.has(unknownKey)) {
+      unknownColumnIndex.set(unknownKey, []);
+    }
+    unknownColumnIndex.get(unknownKey).push(entry);
+  }
+  function getColumnByTableAndColumnName(p) {
+    const source = sources.get(p.table);
+    if (!source) return null;
+    switch (source.kind) {
+      case "table":
+        return source.columns.get(p.column) || null;
+      default:
+        return null;
+    }
+  }
+  function getResolvedColumnsInTable(sourceName) {
+    const source = sources.get(sourceName);
+    if (!source) return [];
+    return getSourceColumns(source).map((x) => x.column);
+  }
+  function getNestedResolvedTargetField(field) {
+    switch (field.kind) {
+      case "column": {
+        const key = `${field.table}.${field.column}`;
+        if (columnIndex.has(key)) {
+          return columnIndex.get(key)?.column ?? null;
+        }
+        break;
+      }
+      case "unknown": {
+        if (unknownColumnIndex.has(field.field)) {
+          const candidates = unknownColumnIndex.get(field.field);
+          if (candidates.length > 0) return candidates[0]?.column ?? null;
+        }
+        break;
+      }
+    }
+    for (const source of sources.values()) {
+      switch (source.kind) {
+        case "cte":
+        case "subselect": {
+          const nested = source.sources.getNestedResolvedTargetField(field);
+          if (nested) {
+            return {
+              ...nested,
+              isNotNull: nested.isNotNull && !checkIsNullableDueToRelation(source.name)
+            };
+          }
+          break;
+        }
+        case "table": {
+          const key = field.kind === "column" ? field.column : field.field;
+          const column = source.columns.get(key);
+          if (column) return column;
+          break;
+        }
+      }
+    }
+    return null;
+  }
+  function getColumnsByTargetField(field) {
+    switch (field.kind) {
+      case "column": {
+        const result = getColumnByTableAndColumnName(field);
+        if (result !== null) {
+          return [result];
+        }
+        for (const source of sources.values()) {
+          switch (source.kind) {
+            case "subselect": {
+              const column = source.sources.getNestedResolvedTargetField(field);
+              if (column) {
+                const isNullableDueToRelation = checkIsNullableDueToRelation(source.name);
+                if (isNullableDueToRelation && column.isNotNull) {
+                  return [{ ...column, isNotNull: false }];
+                }
+                return [column];
+              }
+              break;
+            }
+          }
+        }
+        return null;
+      }
+      case "unknown": {
+        const source = sources.get(field.field);
+        if (source !== void 0) {
+          return getSourceColumns(source).map((x) => x.column);
+        }
+        const foundColumn = getNestedResolvedTargetField(field);
+        if (foundColumn) {
+          return [foundColumn];
+        }
+        for (const source2 of sources.values()) {
+          switch (source2.kind) {
+            case "subselect": {
+              const columns = source2.sources.getColumnsByTargetField(field);
+              if (columns) {
+                const isNullableDueToRelation = checkIsNullableDueToRelation(source2.name);
+                if (isNullableDueToRelation) {
+                  return columns.map((col) => col.isNotNull ? { ...col, isNotNull: false } : col);
+                }
+                return columns;
+              }
+              break;
+            }
+          }
+        }
+        return null;
+      }
+    }
+  }
+  function checkIsNullableDueToRelation(key) {
+    const rel = relationsByAlias.get(key);
+    if (rel !== void 0) {
+      switch (rel.joinType) {
+        case JoinType.JOIN_LEFT:
+        case JoinType.JOIN_FULL:
+          return true;
+        case JoinType.JOIN_TYPE_UNDEFINED:
+        case JoinType.JOIN_INNER:
+        case JoinType.JOIN_RIGHT:
+        case JoinType.JOIN_SEMI:
+        case JoinType.JOIN_ANTI:
+        case JoinType.JOIN_UNIQUE_OUTER:
+        case JoinType.JOIN_UNIQUE_INNER:
+        case JoinType.UNRECOGNIZED:
+          return false;
+        default:
+          return checkSql_utils.assertNever(rel.joinType);
+      }
+    }
+    for (const relation of relationsByRelName.get(key) ?? []) {
+      switch (relation.joinType) {
+        case JoinType.JOIN_RIGHT:
+        case JoinType.JOIN_FULL:
+          return true;
+        case JoinType.JOIN_TYPE_UNDEFINED:
+        case JoinType.JOIN_INNER:
+        case JoinType.JOIN_LEFT:
+        case JoinType.JOIN_SEMI:
+        case JoinType.JOIN_ANTI:
+        case JoinType.JOIN_UNIQUE_OUTER:
+        case JoinType.JOIN_UNIQUE_INNER:
+        case JoinType.UNRECOGNIZED:
+          return false;
+        default:
+          return checkSql_utils.assertNever(relation.joinType);
+      }
+    }
+    return false;
+  }
+  function resolveColumn(col, source) {
+    const keyForNullability = source.alias ? source.alias : source.original;
+    const isNullableDueToRelation = checkIsNullableDueToRelation(keyForNullability);
+    const isNotNullBasedOnAST = nonNullableColumns.has(col.colName) || nonNullableColumns.has(`${source.name}.${col.colName}`);
+    const isNotNullInTable = col.colNotNull;
+    const isNonNullable = isNotNullBasedOnAST || isNotNullInTable && !isNullableDueToRelation;
+    return { column: col, isNotNull: isNonNullable };
+  }
+  return {
+    getNodeColumnAndSources,
+    getResolvedColumnsInTable,
+    getAllResolvedColumns,
+    getColumnsByTargetField,
+    getNestedResolvedTargetField,
+    sources
+  };
+}
+
+const nonNullFunctions = /* @__PURE__ */ new Set([
+  "count",
+  "now",
+  "abs",
+  "ceil",
+  "floor",
+  "round",
+  "sqrt",
+  "cbrt",
+  "exp",
+  "log",
+  "log10",
+  "sin",
+  "cos",
+  "tan",
+  "asin",
+  "acos",
+  "atan",
+  "radians",
+  "degrees",
+  "length",
+  "trim",
+  "lower",
+  "upper",
+  "ascii",
+  "concat",
+  "concat_ws",
+  "lpad",
+  "rpad",
+  "initcap",
+  "left",
+  "right",
+  "cdat",
+  "chr",
+  "strpos",
+  "substr",
+  "translate",
+  "current_date",
+  "current_time",
+  "current_timestamp",
+  "localtime",
+  "localtimestamp",
+  "uuid_generate_v1",
+  "uuid_generate_v4",
+  "pi",
+  "random",
+  "exists",
+  "row_number",
+  "current_schema",
+  "current_schemas",
+  "inet_server_addr",
+  "inet_server_port",
+  "isfinite",
+  "isnan",
+  "pg_backend_pid",
+  "pg_blocking_pids",
+  "pg_cancel_backend",
+  "pg_is_in_recovery",
+  "pg_postmaster_start_time",
+  "pg_relation_size",
+  "pg_total_relation_size",
+  "timeofday",
+  "similar_to_escape"
+]);
+function concatStringNodes$1(nodes) {
+  return nodes?.map((x) => x.String?.sval).filter(Boolean).join(".") ?? "";
+}
+function isColumnNonNullable(val, root) {
+  if (val === void 0) {
+    return false;
+  }
+  if (val.NullTest) {
+    return true;
+  }
+  if (val.BoolExpr?.boolop === BoolExprType.NOT_EXPR) {
+    return true;
+  }
+  if (val.A_Const) {
+    return val.A_Const.isnull !== true;
+  }
+  if (val.FuncCall) {
+    const functionName = concatStringNodes$1(val.FuncCall.funcname);
+    return nonNullFunctions.has(functionName.toLowerCase());
+  }
+  if (val.TypeCast?.arg) {
+    return isColumnNonNullable(val.TypeCast.arg, root);
+  }
+  if (val.SubLink) {
+    switch (val.SubLink.subLinkType) {
+      case SubLinkType.EXISTS_SUBLINK:
+        return true;
+      case SubLinkType.ARRAY_SUBLINK:
+        return true;
+      // while the array itself can be non-nullable, the elements can be nullable
+      case SubLinkType.ALL_SUBLINK:
+      case SubLinkType.ANY_SUBLINK:
+      case SubLinkType.ROWCOMPARE_SUBLINK:
+      case SubLinkType.EXPR_SUBLINK:
+      case SubLinkType.MULTIEXPR_SUBLINK:
+      case SubLinkType.CTE_SUBLINK:
+        return isColumnNonNullable(val.SubLink.subselect, root);
+      case SubLinkType.SUB_LINK_TYPE_UNDEFINED:
+      case SubLinkType.UNRECOGNIZED:
+        return false;
+      default:
+        checkSql_utils.assertNever(val.SubLink.subLinkType);
+    }
+  }
+  if (val.A_Expr?.kind === AExprKind.AEXPR_SIMILAR) {
+    return true;
+  }
+  if (val.A_Expr?.kind === AExprKind.AEXPR_LIKE) {
+    return true;
+  }
+  if (val.A_Expr?.kind === AExprKind.AEXPR_OP) {
+    return isColumnNonNullable(val.A_Expr.lexpr, root) && isColumnNonNullable(val.A_Expr.rexpr, root);
+  }
+  if (val.CaseExpr) {
+    for (const when of val.CaseExpr.args) {
+      if (!isColumnNonNullable(when.CaseWhen?.result, root)) {
+        return false;
+      }
+    }
+    if (val.CaseExpr.defresult && !isColumnNonNullable(val.CaseExpr.defresult, root)) {
+      return false;
+    }
+    return true;
+  }
+  if (val.ColumnRef) {
+    const refColumnName = concatStringNodes$1(val.ColumnRef.fields);
+    for (const stmt of root.stmts) {
+      if (stmt?.stmt?.SelectStmt?.whereClause) {
+        const whereClause = stmt.stmt.SelectStmt.whereClause;
+        const whereClauseColumnName = concatStringNodes$1(
+          whereClause.NullTest?.arg?.ColumnRef?.fields
+        );
+        if (whereClause.NullTest?.nulltesttype === NullTestType.IS_NOT_NULL && whereClauseColumnName === refColumnName) {
+          return true;
+        }
+      }
+    }
+  }
+  if (val.CoalesceExpr) {
+    for (const arg of val.CoalesceExpr.args) {
+      if (isColumnNonNullable(arg, root)) {
+        return true;
+      }
+    }
+  }
+  if (val.A_ArrayExpr) {
+    return true;
+  }
+  if (val.SelectStmt) {
+    const nonNullableColumnsInSubStmt = getNonNullableColumnsInSelectStmt(val.SelectStmt, root);
+    return Array.from(nonNullableColumnsInSubStmt.values()).some(Boolean);
+  }
+  return false;
+}
+function getNodeName(node) {
+  if (node?.ColumnRef !== void 0) {
+    return concatStringNodes$1(node.ColumnRef.fields);
+  }
+  if (node?.NullTest) {
+    return getNodeName(node.NullTest.arg);
+  }
+  if (node?.A_Const?.boolval !== void 0) {
+    return "bool";
+  }
+  if (node?.TypeCast !== void 0) {
+    const typeName = concatStringNodes$1(node.TypeCast.typeName?.names);
+    if (typeName === "pg_catalog.interval") {
+      return "interval";
+    }
+    if (node.TypeCast.arg) {
+      return getNodeName(node.TypeCast.arg);
+    }
+    return typeName.replace(/^pg_catalog\./, "");
+  }
+  if (node?.FuncCall?.funcname !== void 0) {
+    return concatStringNodes$1(node.FuncCall.funcname);
+  }
+  if (node?.SubLink?.subLinkType === SubLinkType.EXISTS_SUBLINK) {
+    return "exists";
+  }
+  if (node?.SubLink?.subLinkType === SubLinkType.ARRAY_SUBLINK) {
+    return "array";
+  }
+  if (node?.SubLink?.subselect?.SelectStmt?.targetList !== void 0) {
+    const subSelectTargetList = node.SubLink.subselect.SelectStmt.targetList;
+    if (subSelectTargetList?.[0].ResTarget !== void 0) {
+      return getTargetName(subSelectTargetList[0].ResTarget);
+    }
+  }
+  if (node?.A_ArrayExpr !== void 0) {
+    return "array";
+  }
+  if (node?.CaseExpr !== void 0) {
+    return "case";
+  }
+  if (node?.CoalesceExpr !== void 0) {
+    return "coalesce";
+  }
+  return "?column?";
+}
+function getTargetName(target) {
+  return target.name ?? getNodeName(target.val);
+}
+function getNonNullableColumnsInSelectStmt(stmt, root) {
+  const nonNullableColumns = /* @__PURE__ */ new Set();
+  const targetList = [
+    ...stmt.targetList ?? [],
+    ...stmt.larg?.targetList ?? [],
+    ...stmt.rarg?.targetList ?? []
+  ];
+  const targetNames = /* @__PURE__ */ new Set();
+  for (const target of targetList) {
+    if (target.ResTarget) {
+      targetNames.add(getTargetName(target.ResTarget));
+    }
+    if (target.ResTarget && isColumnNonNullable(target.ResTarget.val, root)) {
+      nonNullableColumns.add(getTargetName(target.ResTarget));
+    }
+  }
+  if (stmt.whereClause) {
+    if (stmt.whereClause.NullTest?.nulltesttype === NullTestType.IS_NOT_NULL) {
+      const colRef = stmt.whereClause.NullTest.arg?.ColumnRef;
+      const whereClauseName = concatStringNodes$1(colRef?.fields);
+      switch (true) {
+        case targetNames.has(whereClauseName):
+          nonNullableColumns.add(whereClauseName);
+          break;
+        case targetNames.has(colRef?.fields?.at(-1)?.String?.sval ?? ""):
+          nonNullableColumns.add(colRef?.fields?.at(-1)?.String?.sval ?? "");
+          break;
+        default:
+          nonNullableColumns.add(whereClauseName);
+          break;
+      }
+    }
+    if (stmt.whereClause.BoolExpr?.boolop === BoolExprType.AND_EXPR) {
+      for (const arg of stmt.whereClause.BoolExpr.args) {
+        if (arg.NullTest?.nulltesttype === NullTestType.IS_NOT_NULL && arg.NullTest.arg?.ColumnRef?.fields) {
+          nonNullableColumns.add(concatStringNodes$1(arg.NullTest.arg.ColumnRef.fields));
+        }
+      }
+    }
+  }
+  return nonNullableColumns;
+}
+function getNonNullableColumns(root) {
+  for (const stmt of root.stmts) {
+    if (stmt.stmt?.SelectStmt) {
+      return getNonNullableColumnsInSelectStmt(stmt.stmt.SelectStmt, root);
+    }
+  }
+  return /* @__PURE__ */ new Set();
+}
+
+function getRelationsWithJoins(parsed) {
+  const results = /* @__PURE__ */ new Map();
+  const stmt = parsed.stmts[0];
+  if (stmt === void 0 || stmt?.stmt?.SelectStmt?.fromClause === void 0) {
+    return results;
+  }
+  for (const fromClause of stmt.stmt.SelectStmt.fromClause) {
+    if (fromClause.JoinExpr !== void 0) {
+      const { relName, joins } = recursiveTraverseJoins([], fromClause.JoinExpr);
+      results.set(relName, joins);
+    }
+  }
+  return results;
+}
+function recursiveGetJoinName(joinExpr) {
+  if (joinExpr.rarg?.JoinExpr !== void 0) {
+    return recursiveGetJoinName(joinExpr.rarg.JoinExpr);
+  }
+  return joinExpr.rarg?.RangeVar?.relname ?? joinExpr.rarg?.RangeSubselect?.alias?.aliasname;
+}
+function recursiveTraverseJoins(joins, joinExpr) {
+  const joinName = recursiveGetJoinName(joinExpr);
+  const aliasName = joinExpr.rarg?.RangeVar?.alias?.aliasname;
+  if (joinName === void 0) {
+    throw new Error("joinName is undefined");
+  }
+  const join = { type: joinExpr.jointype, name: joinName, alias: aliasName };
+  if (joinExpr.larg?.JoinExpr !== void 0) {
+    return recursiveTraverseJoins([join, ...joins], joinExpr.larg?.JoinExpr);
+  }
+  if (joinExpr.rarg?.JoinExpr !== void 0) {
+    return recursiveTraverseJoins([join, ...joins], joinExpr.rarg?.JoinExpr);
+  }
+  const relName = joinExpr.larg?.RangeVar?.relname ?? joinExpr.larg?.RangeFunction?.alias?.aliasname ?? joinExpr.rarg?.RangeVar?.relname ?? joinExpr.rarg?.RangeFunction?.alias?.aliasname;
+  if (relName === void 0) {
+    throw new Error("relName is undefined");
+  }
+  return { relName, joins: [join, ...joins] };
+}
+function flattenRelationsWithJoinsMap(relationsWithJoinsMap) {
+  const result = [];
+  relationsWithJoinsMap.forEach((joins, relName) => {
+    joins.forEach((join) => {
+      result.push({ relName, joinType: join.type, joinRelName: join.name, alias: join.alias });
+    });
+  });
+  return result;
+}
+
+function getASTDescription(params) {
+  const select = params.parsed.stmts[0]?.stmt?.SelectStmt;
+  if (select === void 0) {
+    return {
+      map: /* @__PURE__ */ new Map(),
+      meta: {
+        relations: [],
+        nonNullableColumns: /* @__PURE__ */ new Set()
+      }
+    };
+  }
+  const nonNullableColumns = getNonNullableColumns(params.parsed);
+  const relations = flattenRelationsWithJoinsMap(getRelationsWithJoins(params.parsed));
+  function getTypeByOid(oid) {
+    const name = params.pgTypes.get(oid)?.name;
+    if (name === void 0) {
+      return { isArray: false, override: false, value: "unknown" };
+    }
+    const { isArray, typeName } = name.startsWith("_") ? { isArray: true, typeName: name.slice(1) } : { isArray: false, typeName: name };
+    const resolvedTypeName = params.typesMap.get(typeName) ?? { override: false, value: "unknown" };
+    return {
+      isArray,
+      override: resolvedTypeName.override,
+      value: resolvedTypeName.value
+    };
+  }
+  const context = {
+    ...params,
+    nonNullableColumns,
+    relations,
+    resolver: getSources({
+      relations,
+      select,
+      nonNullableColumns,
+      pgColsBySchemaAndTableName: params.pgColsBySchemaAndTableName
+    }),
+    select,
+    resolved: /* @__PURE__ */ new WeakMap(),
+    toTypeScriptType: (p) => {
+      if ("name" in p) {
+        return {
+          kind: "type",
+          value: params.typesMap.get(p.name)?.value ?? "unknown",
+          type: p.name
+        };
+      }
+      const pgType = params.pgTypes.get(p.oid);
+      const typeByOid = getTypeByOid(p.oid);
+      if (typeByOid.override) {
+        const baseType = {
+          kind: "type",
+          value: typeByOid.value,
+          type: pgType?.name ?? "unknown"
+        };
+        return typeByOid.isArray ? { kind: "array", value: baseType } : baseType;
+      }
+      const typeByBaseOid = checkSql_utils.fmap(p.baseOid, getTypeByOid);
+      if (typeByBaseOid?.override === true) {
+        const baseType = {
+          kind: "type",
+          value: typeByBaseOid.value,
+          type: params.pgTypes.get(p.baseOid)?.name ?? "unknown"
+        };
+        return typeByBaseOid.isArray ? { kind: "array", value: baseType } : baseType;
+      }
+      const getEnumByOid = (oid) => {
+        const pgEnum = params.pgEnums.get(oid);
+        if (pgEnum === void 0) {
+          return void 0;
+        }
+        return {
+          kind: "union",
+          value: pgEnum.values.map((value2) => ({
+            kind: "type",
+            value: `'${value2}'`,
+            type: pgEnum.name
+          }))
+        };
+      };
+      const valueAsEnum = (() => {
+        const enumType = getEnumByOid(p.oid);
+        if (enumType !== void 0) {
+          return enumType;
+        }
+        if (pgType?.typelem !== void 0 && pgType.typelem !== 0) {
+          const arrayEnumValue = getEnumByOid(pgType.typelem);
+          if (arrayEnumValue !== void 0) {
+            return {
+              kind: "array",
+              value: arrayEnumValue
+            };
+          }
+        }
+        return void 0;
+      })();
+      if (valueAsEnum !== void 0) {
+        return valueAsEnum;
+      }
+      const { isArray, value } = typeByBaseOid ?? typeByOid;
+      const type = {
+        kind: "type",
+        value,
+        type: pgType?.name ?? "unknown"
+      };
+      if (p.baseOid !== null) {
+        type.base = params.pgTypes.get(p.baseOid)?.name;
+      }
+      return isArray ? { kind: "array", value: type } : type;
+    }
+  };
+  const targetLists = [select.targetList, select.larg?.targetList, select.rarg?.targetList].filter(
+    (x) => x !== void 0
+  );
+  const resolvedColumnsList = [];
+  for (const [targetListIdx, targetList] of targetLists.entries()) {
+    resolvedColumnsList[targetListIdx] = targetList.map((target) => {
+      const described = getDescribedNode({
+        alias: void 0,
+        node: target,
+        context
+      });
+      if (described.length === 0) {
+        return [void 0];
+      }
+      return described;
+    }).flat();
+  }
+  const columnsLength = resolvedColumnsList.reduce((acc, x) => Math.max(acc, x.length), 0);
+  const final = /* @__PURE__ */ new Map();
+  for (let i = 0; i < columnsLength; i++) {
+    const result = mergeColumns(resolvedColumnsList.map((x) => x[i]));
+    final.set(i, result);
+  }
+  return {
+    map: final,
+    meta: {
+      relations,
+      nonNullableColumns
+    }
+  };
+}
+function mergeColumns(columns) {
+  const definedColumns = columns.filter((x) => x !== void 0);
+  if (definedColumns.length === 0) {
+    return void 0;
+  }
+  const name = definedColumns[0].name;
+  const type = mergeDescribedColumnTypes(definedColumns.map((x) => x.type));
+  return { name, type };
+}
+function getDescribedNode(params) {
+  const { alias, node, context } = params;
+  if (node.ResTarget !== void 0) {
+    return getDescribedResTarget({ node: node.ResTarget, context });
+  }
+  if (node.A_Const !== void 0) {
+    return getDescribedAConst({ alias, node: node.A_Const, context });
+  }
+  if (node.ColumnRef !== void 0) {
+    return getDescribedColumnRef({ alias, node: node.ColumnRef, context });
+  }
+  if (node.FuncCall !== void 0) {
+    return getDescribedFuncCall({ alias, node: node.FuncCall, context });
+  }
+  if (node.TypeCast !== void 0) {
+    return getDescribedTypeCast({ alias, node: node.TypeCast, context });
+  }
+  if (node.A_ArrayExpr !== void 0) {
+    return getDescribedArrayExpr({ alias, node: node.A_ArrayExpr, context });
+  }
+  if (node.CoalesceExpr !== void 0) {
+    return getDescribedCoalesceExpr({ alias, node: node.CoalesceExpr, context });
+  }
+  if (node.SubLink !== void 0) {
+    return getDescribedSubLink({ alias, node: node.SubLink, context });
+  }
+  if (node.BoolExpr !== void 0) {
+    return getDescribedBoolExpr({ alias, node: node.BoolExpr, context });
+  }
+  if (node.CaseExpr !== void 0) {
+    return getDescribedCaseExpr({ alias, node: node.CaseExpr, context });
+  }
+  if (node.NullTest !== void 0) {
+    return getDescribedNullTest({ alias, node: node.NullTest, context });
+  }
+  if (node.A_Expr !== void 0) {
+    return getDescribedAExpr({ alias, node: node.A_Expr, context });
+  }
+  if (node.SelectStmt !== void 0) {
+    return getDescribedSelectStmt({ alias, node: node.SelectStmt, context });
+  }
+  return [];
+}
+function getDescribedAExpr({
+  alias,
+  node,
+  context
+}) {
+  const name = alias ?? "?column?";
+  if (node.lexpr === void 0 && node.rexpr !== void 0) {
+    const described = getDescribedNode({ alias, node: node.rexpr, context }).at(0);
+    const type2 = checkSql_utils.fmap(described, (x) => getBaseType(x.type));
+    if (type2 === null) return [];
+    return [{ name, type: type2 }];
+  }
+  if (node.lexpr === void 0 || node.rexpr === void 0) {
+    return [];
+  }
+  const getResolvedNullableValueOrNull = (node2) => {
+    const column = getDescribedNode({ alias: void 0, node: node2, context }).at(0);
+    if (column === void 0) return null;
+    const getFromType = (type2) => {
+      switch (true) {
+        case type2.kind === "type":
+          return { value: type2.base ?? type2.type, array: false, nullable: false };
+        case (type2.kind === "literal" && type2.base.kind === "type"):
+          return { value: type2.base.type, array: false, nullable: false };
+        case (type2.kind === "union" && type2.value.every((x) => x.kind === "literal")): {
+          const resolved = getFromType(type2.value[0].base);
+          if (resolved === null) return null;
+          return { value: resolved.value, nullable: false, array: false };
+        }
+        case (type2.kind === "union" && isTuple(type2.value)): {
+          let nullable = false;
+          let value = void 0;
+          for (const valueType of type2.value) {
+            if (valueType.kind !== "type") return null;
+            if (valueType.value === "null") nullable = true;
+            if (valueType.value !== "null") value = valueType.type;
+          }
+          if (value === void 0) return null;
+          return { value, nullable, array: false };
+        }
+        case type2.kind === "object":
+          return { value: "jsonb", array: false, nullable: false };
+        default:
+          return null;
+      }
+    };
+    if (column.type.kind === "array") {
+      const resolved = getFromType(column.type.value);
+      if (!resolved) return null;
+      return { value: resolved.value, nullable: resolved.nullable, array: true };
+    }
+    return getFromType(column.type);
+  };
+  const lnode = getResolvedNullableValueOrNull(node.lexpr);
+  const rnode = getResolvedNullableValueOrNull(node.rexpr);
+  const operator = concatStringNodes(node.name);
+  if (lnode === null || rnode === null) {
+    return [];
+  }
+  const downcast = () => {
+    const left = lnode.array ? `_${lnode.value}` : lnode.value;
+    const right = rnode.array ? `_${rnode.value}` : rnode.value;
+    const overrides = {
+      "int4 ^ int4": ["float8", "^", "float8"]
+    };
+    if (overrides[`${left} ${operator} ${right}`]) {
+      return overrides[`${left} ${operator} ${right}`];
+    }
+    const adjust = (value) => value === "varchar" ? "text" : value;
+    return [adjust(left), operator, adjust(right)];
+  };
+  const getNullable = () => {
+    if (context.nonNullableColumns.has(name)) {
+      return false;
+    }
+    if (lnode.nullable || rnode.nullable) {
+      return true;
+    }
+    const operatorForcesNullable = ["->>", "#>>"].includes(operator) && hasColumnReference(node.lexpr);
+    return operatorForcesNullable;
+  };
+  const getType = () => {
+    const nullable = getNullable();
+    const [dleft, doperator, dright] = downcast();
+    const type2 = context.typeExprMap.get(dleft)?.get(doperator)?.get(dright) ?? context.typeExprMap.get("anycompatiblearray")?.get(operator)?.get("anycompatiblearray") ?? context.typeExprMap.get("anyarray")?.get(operator)?.get("anyarray") ?? context.typeExprMap.get(lnode.value)?.get(operator)?.values().next().value;
+    if (type2 === void 0) {
+      return;
+    }
+    if (type2 === "anycompatiblearray") {
+      return {
+        kind: "array",
+        value: resolveType({
+          context,
+          nullable,
+          type: context.toTypeScriptType({ name: lnode.value })
+        })
+      };
+    }
+    return resolveType({
+      context,
+      nullable,
+      type: context.toTypeScriptType({ name: type2 })
+    });
+  };
+  const type = getType();
+  if (type === void 0) {
+    return [];
+  }
+  return [{ name, type }];
+}
+function getDescribedNullTest({
+  alias,
+  context
+}) {
+  return [
+    {
+      name: alias ?? "?column?",
+      type: resolveType({
+        context,
+        nullable: false,
+        type: context.toTypeScriptType({ name: "bool" })
+      })
+    }
+  ];
+}
+function getDescribedCaseExpr({
+  alias,
+  node,
+  context
+}) {
+  const results = [];
+  for (const arg of node.args) {
+    if (arg.CaseWhen?.result !== void 0) {
+      results.push(getDescribedNode({ alias: void 0, node: arg.CaseWhen.result, context }));
+    }
+  }
+  results.push(
+    node.defresult !== void 0 ? getDescribedNode({ alias: void 0, node: node.defresult, context }) : [{ name: "?column?", type: context.toTypeScriptType({ name: "null" }) }]
+  );
+  const types = results.flat().map((x) => x.type);
+  const literalsOnly = types.some((x) => x.kind !== "literal" && x.value !== "null");
+  const value = mergeDescribedColumnTypes(literalsOnly ? types.map(getBaseType) : types);
+  return [
+    {
+      name: alias ?? "case",
+      type: value
+    }
+  ];
+}
+function getBaseType(type) {
+  switch (type.kind) {
+    case "object":
+    case "union":
+    case "array":
+    case "type":
+      return type;
+    case "literal":
+      return type.base;
+  }
+}
+function getDescribedBoolExpr({
+  alias,
+  context
+}) {
+  return [
+    {
+      name: alias ?? "?column?",
+      type: resolveType({
+        context,
+        nullable: false,
+        type: context.toTypeScriptType({ name: "bool" })
+      })
+    }
+  ];
+}
+function getDescribedSubLink({
+  alias,
+  context,
+  node
+}) {
+  const getSubLinkType = () => {
+    if (node.subLinkType === SubLinkType.EXISTS_SUBLINK) {
+      return context.toTypeScriptType({ name: "bool" });
+    }
+    if (node.subLinkType === SubLinkType.EXPR_SUBLINK) {
+      const described = node.subselect?.SelectStmt ? getDescribedNode({
+        alias: void 0,
+        node: { SelectStmt: node.subselect.SelectStmt },
+        context
+      }) : [];
+      return described.length > 0 ? described[0].type : context.toTypeScriptType({ name: "unknown" });
+    }
+    return context.toTypeScriptType({ name: "unknown" });
+  };
+  return [
+    {
+      name: alias ?? "exists",
+      type: resolveType({
+        context,
+        nullable: false,
+        type: getSubLinkType()
+      })
+    }
+  ];
+}
+function getDescribedSelectStmt({
+  alias,
+  context,
+  node
+}) {
+  const subParsed = {
+    version: 0,
+    stmts: [{ stmt: { SelectStmt: node }, stmtLocation: 0, stmtLen: 0 }]
+  };
+  const subDescription = getASTDescription({
+    parsed: subParsed,
+    typesMap: context.typesMap,
+    typeExprMap: context.typeExprMap,
+    overridenColumnTypesMap: context.overridenColumnTypesMap,
+    pgColsBySchemaAndTableName: context.pgColsBySchemaAndTableName,
+    pgTypes: context.pgTypes,
+    pgEnums: context.pgEnums,
+    pgFns: context.pgFns,
+    fieldTransform: context.fieldTransform
+  });
+  const firstColumn = subDescription.map.get(0);
+  if (firstColumn) {
+    return [
+      {
+        name: alias ?? firstColumn.name,
+        type: firstColumn.type
+      }
+    ];
+  }
+  return [];
+}
+function getDescribedCoalesceExpr({
+  alias,
+  context,
+  node
+}) {
+  const firstArg = node.args.at(0);
+  const unknownCoalesce = {
+    name: alias ?? "coalesce",
+    type: context.toTypeScriptType({ name: "unknown" })
+  };
+  if (firstArg === void 0) {
+    return [unknownCoalesce];
+  }
+  const type = getDescribedNode({ alias: void 0, node: firstArg, context }).map((x) => asNonNullableType(x.type)).at(0);
+  if (type === void 0) {
+    return [];
+  }
+  return [
+    {
+      name: alias ?? "coalesce",
+      type
+    }
+  ];
+}
+function getDescribedArrayExpr({
+  alias,
+  context,
+  node
+}) {
+  const types = mergeDescribedColumnTypes(
+    node.elements.flatMap((node2) => getDescribedNode({ alias: void 0, node: node2, context })).map((x) => x.type)
+  );
+  return [
+    {
+      name: alias ?? "?column?",
+      type: {
+        kind: "array",
+        value: types
+      }
+    }
+  ];
+}
+function mergeDescribedColumnTypes(types) {
+  const result = [];
+  const seenSymbols = /* @__PURE__ */ new Set();
+  function processType(type) {
+    switch (type.kind) {
+      case "union":
+        type.value.forEach((subtype) => processType(subtype));
+        break;
+      case "type":
+      case "literal":
+        if (!seenSymbols.has(type.value)) {
+          seenSymbols.add(type.value);
+          result.push(type);
+        }
+        break;
+      case "object":
+      case "array":
+        result.push(type);
+        break;
+    }
+  }
+  for (const t of types) {
+    processType(t);
+  }
+  if (!seenSymbols.has("boolean") && seenSymbols.has("true") && seenSymbols.has("false")) {
+    seenSymbols.add("boolean");
+    result.push({ kind: "type", value: "boolean", type: "bool" });
+  }
+  if (seenSymbols.has("boolean") && (seenSymbols.has("true") || seenSymbols.has("false"))) {
+    const filtered = result.filter(
+      (t) => !(t.kind === "literal" && (t.value === "true" || t.value === "false"))
+    );
+    return isSingleCell(filtered) ? filtered[0] : { kind: "union", value: filtered };
+  }
+  return isSingleCell(result) ? result[0] : { kind: "union", value: result };
+}
+function getDescribedTypeCast({
+  alias,
+  context,
+  node
+}) {
+  let typeName = node.typeName?.names.at(-1)?.String?.sval;
+  if (typeName === "int") {
+    typeName = "int4";
+  }
+  if (typeName === void 0 || node.arg === void 0) {
+    return [];
+  }
+  const type = context.toTypeScriptType({ name: typeName });
+  const innerDescribed = getDescribedNode({ alias, node: node.arg, context }).at(0);
+  const nullable = checkSql_utils.fmap(innerDescribed, (x) => isDescribedColumnNullable(x.type)) ?? true;
+  switch (true) {
+    case node.arg.FuncCall !== void 0: {
+      return [
+        {
+          name: alias ?? node.arg.FuncCall?.funcname.at(-1)?.String?.sval ?? "?column?",
+          type: resolveType({ context, nullable, type })
+        }
+      ];
+    }
+    case node.arg.ColumnRef !== void 0: {
+      return [
+        {
+          name: alias ?? concatStringNodes(node.arg.ColumnRef.fields),
+          type: resolveType({ context, nullable, type })
+        }
+      ];
+    }
+    default: {
+      return [
+        {
+          name: alias ?? typeName ?? "?column?",
+          type: resolveType({ context, nullable, type })
+        }
+      ];
+    }
+  }
+}
+function getDescribedResTarget(params) {
+  const { node, context } = params;
+  if (node.val === void 0) {
+    return [];
+  }
+  return getDescribedNode({
+    alias: node.name,
+    context,
+    node: node.val
+  });
+}
+function getDescribedFuncCall(params) {
+  const functionName = params.node.funcname.at(-1)?.String?.sval;
+  if (functionName === void 0) {
+    return [];
+  }
+  switch (true) {
+    case functionName === "json_build_object":
+    case functionName === "jsonb_build_object":
+      return getDescribedJsonBuildObjectFunCall(params);
+    case functionName === "json_agg":
+    case functionName === "jsonb_agg":
+      return getDescribedJsonAggFunCall(params);
+    case functionName === "array_agg":
+      return getDescribedArrayAggFunCall(params);
+    case functionName === "unnest":
+      return getDescribedUnnestFunCall(params);
+    default:
+      return getDescribedFuncCallByPgFn(params);
+  }
+}
+function getDescribedUnnestFunCall({
+  alias,
+  context,
+  node
+}) {
+  const functionName = node.funcname.at(-1)?.String?.sval ?? "";
+  const name = alias ?? functionName;
+  const firstArg = node.args?.at(0);
+  if (firstArg === void 0) {
+    return [{ name, type: context.toTypeScriptType({ name: "unknown" }) }];
+  }
+  const described = getDescribedNode({ alias: void 0, node: firstArg, context }).at(0);
+  if (described === void 0) {
+    return [{ name, type: context.toTypeScriptType({ name: "unknown" }) }];
+  }
+  function unwrap(type) {
+    if (type.kind === "array") {
+      return unwrap(type.value);
+    }
+    if (type.kind === "union") {
+      const hasArray = type.value.some((t) => t.kind === "array");
+      const unwrapped = type.value.filter((t) => !hasArray || !(t.kind === "type" && t.value === "null")).map(unwrap);
+      return mergeDescribedColumnTypes(unwrapped);
+    }
+    if (type.kind === "type" && type.type.startsWith("_")) {
+      return { ...type, type: type.type.slice(1) };
+    }
+    return type;
+  }
+  return [{ name, type: unwrap(described.type) }];
+}
+function getDescribedFuncCallByPgFn({
+  alias,
+  context,
+  node
+}) {
+  const functionName = node.funcname.at(-1)?.String?.sval;
+  const name = alias ?? functionName ?? "?column?";
+  const args = (node.args ?? []).flatMap((node2) => {
+    const described = getDescribedNode({ alias: void 0, node: node2, context }).at(0);
+    if (described?.type.kind === "type") {
+      return [described.type.value];
+    }
+    return [];
+  });
+  if (functionName === void 0) {
+    return [{ name, type: context.toTypeScriptType({ name: "unknown" }) }];
+  }
+  const pgFnValue = args.length === 0 ? context.pgFns.get(functionName) ?? context.pgFns.get(`${functionName}(string)`) : context.pgFns.get(`${functionName}(${args.join(", ")})`) ?? context.pgFns.get(`${functionName}(any)`) ?? context.pgFns.get(`${functionName}(unknown)`);
+  const type = resolveType({
+    context,
+    nullable: !context.nonNullableColumns.has(name),
+    type: { kind: "type", value: pgFnValue?.ts ?? "unknown", type: pgFnValue?.pg ?? "unknown" }
+  });
+  return [{ name, type }];
+}
+function getDescribedArrayAggFunCall({
+  alias,
+  context,
+  node
+}) {
+  const name = alias ?? concatStringNodes(node.funcname);
+  const firstArg = checkSql_utils.fmap(node.args?.at(0), (node2) => {
+    return {
+      node: node2,
+      described: getDescribedNode({ alias: void 0, node: node2, context })
+    };
+  });
+  if (firstArg === null) {
+    return [
+      {
+        name,
+        type: context.toTypeScriptType({ name: "unknown" })
+      }
+    ];
+  }
+  const isSourceRef = context.resolver.sources.get(concatStringNodes(firstArg.node.ColumnRef?.fields)) !== void 0;
+  const type = resolveType({
+    context,
+    nullable: !context.nonNullableColumns.has(name),
+    type: {
+      kind: "array",
+      value: isSourceRef || firstArg.described.length > 1 ? {
+        kind: "object",
+        value: firstArg.described.map((x) => [x.name, x.type])
+      } : firstArg.described[0].type
+    }
+  });
+  return [{ name, type }];
+}
+function getDescribedJsonAggFunCall({
+  alias,
+  context,
+  node
+}) {
+  const name = alias ?? concatStringNodes(node.funcname);
+  if (node.args === void 0 || !isSingleCell(node.args)) {
+    return [];
+  }
+  const argNode = node.args[0];
+  const cellType = getDescribedNode({ alias: void 0, node: argNode, context });
+  if (cellType.length === 0) {
+    return [];
+  }
+  const isSourceRef = context.resolver.sources.get(concatStringNodes(argNode.ColumnRef?.fields)) !== void 0;
+  const type = resolveType({
+    context,
+    nullable: !context.nonNullableColumns.has(name),
+    type: {
+      kind: "array",
+      value: isSourceRef || cellType.length > 1 ? {
+        kind: "object",
+        value: cellType.map((x) => [x.name, x.type])
+      } : cellType[0].type
+    }
+  });
+  return [{ name, type }];
+}
+function getDescribedJsonBuildObjectFunCall({
+  alias,
+  context,
+  node
+}) {
+  const functionName = node.funcname.at(-1)?.String?.sval ?? "";
+  const name = alias ?? functionName;
+  const unknownDescribedColumn = {
+    name,
+    type: context.toTypeScriptType({ name: "unknown" })
+  };
+  if (node.args === void 0) {
+    return [unknownDescribedColumn];
+  }
+  const describedColumn = { kind: "object", value: [] };
+  for (const [idx, arg] of node.args.entries()) {
+    if (idx % 2 === 1) {
+      continue;
+    }
+    const valueNode = node.args.at(idx + 1);
+    if (valueNode === void 0) {
+      throw new Error(checkSql_utils.normalizeIndent`
+          argument list must have even number of elements
+          Hint: The arguments of ${functionName}() must consist of alternating keys and values.
+        `);
+    }
+    const alias2 = arg.A_Const?.sval?.sval;
+    const type = checkSql_utils.fmap(node.args[idx + 1], (node2) => {
+      return getDescribedNode({ alias: alias2, node: node2, context }).at(0)?.type ?? null;
+    });
+    if (alias2 === void 0 || type === null) {
+      return [unknownDescribedColumn];
+    }
+    const transformedKey = checkSql_utils.toCase(alias2, context.fieldTransform);
+    describedColumn.value.push([transformedKey, resolveType({ context, nullable: false, type })]);
+  }
+  return [
+    {
+      name,
+      type: describedColumn
+    }
+  ];
+}
+function getColumnRefOrigins({
+  context,
+  node
+}) {
+  if (isColumnTableStarRef(node.fields)) {
+    const source = node.fields[0].String.sval;
+    return (
+      // lookup in cte
+      context.select.withClause?.ctes.find((cte) => cte.CommonTableExpr?.ctename === source)?.CommonTableExpr?.ctequery?.SelectStmt?.targetList ?? // lookup in subselect
+      context.select.fromClause?.map((from) => from.RangeSubselect).find((subselect) => subselect?.alias?.aliasname === source)?.subquery?.SelectStmt?.targetList
+    );
+  }
+  if (isColumnTableColumnRef(node.fields)) {
+    const source = node.fields[0].String.sval;
+    const column = node.fields[1].String.sval;
+    const origin = (
+      // lookup in cte
+      context.select.withClause?.ctes.find((cte) => cte.CommonTableExpr?.ctename === source)?.CommonTableExpr?.ctequery?.SelectStmt?.targetList?.find(
+        (x) => x.ResTarget?.name === column
+      ) ?? // lookup in subselect
+      context.select.fromClause?.map((from) => from.RangeSubselect).find((subselect) => subselect?.alias?.aliasname === source)?.subquery?.SelectStmt?.targetList?.find((x) => x.ResTarget?.name === column)
+    );
+    if (!origin) return void 0;
+    return [origin];
+  }
+}
+function getContextForColumnRef(context, node) {
+  if (isColumnTableColumnRef(node.fields) || isColumnTableStarRef(node.fields)) {
+    const sourceName = node.fields[0].String.sval;
+    const source = context.resolver.sources.get(sourceName);
+    if (source?.kind === "cte") {
+      return { ...context, resolver: source.sources };
+    }
+  }
+  return context;
+}
+function getDescribedColumnRef({
+  alias,
+  context,
+  node
+}) {
+  const definitionNodes = getColumnRefOrigins({ context, node });
+  if (definitionNodes) {
+    const defContext = getContextForColumnRef(context, node);
+    return definitionNodes.flatMap(
+      (node2) => getDescribedNode({ alias, node: node2, context: defContext })
+    );
+  }
+  return getDescribedColumnRefFromSchema({ alias, context, node });
+}
+function getDescribedColumnRefFromSchema({
+  alias,
+  context,
+  node
+}) {
+  if (isColumnStarRef(node.fields)) {
+    return getDescribedColumnByResolvedColumns({
+      alias,
+      context,
+      resolved: context.resolver.getAllResolvedColumns().map((x) => x.column)
+    });
+  }
+  if (isColumnTableStarRef(node.fields)) {
+    return getDescribedColumnByResolvedColumns({
+      alias,
+      context,
+      resolved: context.resolver.getResolvedColumnsInTable(node.fields[0].String.sval)
+    });
+  }
+  if (isColumnUnknownRef(node.fields)) {
+    const resolved = context.resolver.getColumnsByTargetField({
+      kind: "unknown",
+      field: node.fields[0].String.sval
+    });
+    return getDescribedColumnByResolvedColumns({
+      alias,
+      context,
+      resolved: resolved ?? []
+    });
+  }
+  if (isColumnTableColumnRef(node.fields)) {
+    const resolved = context.resolver.getNestedResolvedTargetField({
+      kind: "column",
+      table: node.fields[0].String.sval,
+      column: node.fields[1].String.sval
+    });
+    return getDescribedColumnByResolvedColumns({
+      alias,
+      context,
+      resolved: checkSql_utils.fmap(resolved, (x) => [x]) ?? []
+    });
+  }
+  return [];
+}
+function getDescribedColumnByResolvedColumns(params) {
+  return params.resolved.map(({ column, isNotNull }) => {
+    const getType = () => {
+      const overridenType = params.context.overridenColumnTypesMap.get(column.tableName)?.get(column.colName);
+      if (overridenType !== void 0) {
+        return {
+          kind: "type",
+          value: overridenType,
+          type: params.context.pgTypes.get(column.colTypeOid)?.name ?? "unknown"
+        };
+      }
+      return params.context.toTypeScriptType({
+        oid: column.colTypeOid,
+        baseOid: column.colBaseTypeOid
+      });
+    };
+    return {
+      name: params.alias ?? column.colName,
+      type: resolveType({
+        context: params.context,
+        nullable: !isNotNull,
+        type: getType()
+      })
+    };
+  });
+}
+function getDescribedAConst({
+  alias,
+  context,
+  node
+}) {
+  const type = (() => {
+    switch (true) {
+      case node.boolval !== void 0:
+        return {
+          kind: "literal",
+          value: node.boolval.boolval ? "true" : "false",
+          base: context.toTypeScriptType({ name: "bool" })
+        };
+      case node.bsval !== void 0:
+        return context.toTypeScriptType({ name: "bytea" });
+      case node.fval !== void 0:
+        return {
+          kind: "literal",
+          value: node.fval.toString(),
+          base: context.toTypeScriptType({ name: "float8" })
+        };
+      case node.isnull !== void 0:
+        return context.toTypeScriptType({ name: "null" });
+      case node.ival !== void 0:
+        return {
+          kind: "literal",
+          value: (node.ival.ival ?? 0).toString(),
+          base: context.toTypeScriptType({ name: "int4" })
+        };
+      case node.sval !== void 0:
+        return {
+          kind: "literal",
+          value: `'${node.sval.sval}'`,
+          base: context.toTypeScriptType({ name: "text" })
+        };
+      default:
+        return context.toTypeScriptType({ name: "unknown" });
+    }
+  })();
+  return [
+    {
+      name: alias ?? "?column?",
+      type: resolveType({ context, nullable: node.isnull === true, type })
+    }
+  ];
+}
+function asNonNullableType(type) {
+  switch (type.kind) {
+    case "object":
+    case "array":
+    case "literal":
+      return type;
+    case "union": {
+      const filtered = type.value.filter(
+        (described) => described.kind !== "type" || described.value !== "null"
+      );
+      if (filtered.length === 0) {
+        return { kind: "type", value: "unknown", type: "unknown" };
+      }
+      if (filtered.length === 1) {
+        return filtered[0];
+      }
+      return { kind: "union", value: filtered };
+    }
+    case "type":
+      return type.value === "null" ? { kind: "type", value: "unknown", type: "unknown" } : type;
+  }
+}
+function isDescribedColumnNullable(type) {
+  return type.kind === "union" && type.value.some((x) => x.kind === "type" && x.value === "null");
+}
+function resolveType(params) {
+  if (params.nullable && params.type.value !== "null") {
+    return {
+      kind: "union",
+      value: [params.type, params.context.toTypeScriptType({ name: "null" })]
+    };
+  }
+  return params.type;
+}
+function concatStringNodes(nodes) {
+  return nodes?.map((x) => x.String?.sval).filter(Boolean).join(".") ?? "";
+}
+function hasColumnReference(node) {
+  if (node === void 0) {
+    return false;
+  }
+  if (node.ColumnRef !== void 0) {
+    return true;
+  }
+  if (node.A_Const !== void 0) {
+    return false;
+  }
+  if (node.TypeCast !== void 0) {
+    return hasColumnReference(node.TypeCast.arg);
+  }
+  if (node.A_Expr !== void 0) {
+    return hasColumnReference(node.A_Expr.lexpr) || hasColumnReference(node.A_Expr.rexpr);
+  }
+  if (node.BoolExpr !== void 0) {
+    return (node.BoolExpr.args ?? []).some(hasColumnReference);
+  }
+  if (node.FuncCall !== void 0) {
+    return (node.FuncCall.args ?? []).some(hasColumnReference);
+  }
+  if (node.CoalesceExpr !== void 0) {
+    return node.CoalesceExpr.args.some(hasColumnReference);
+  }
+  if (node.CaseExpr !== void 0) {
+    if (node.CaseExpr.arg && hasColumnReference(node.CaseExpr.arg)) {
+      return true;
+    }
+    if (node.CaseExpr.defresult && hasColumnReference(node.CaseExpr.defresult)) {
+      return true;
+    }
+    return node.CaseExpr.args.some((caseWhen) => {
+      if (caseWhen.CaseWhen === void 0) {
+        return false;
+      }
+      return hasColumnReference(caseWhen.CaseWhen.expr) || hasColumnReference(caseWhen.CaseWhen.result);
+    });
+  }
+  if (node.A_ArrayExpr !== void 0) {
+    return (node.A_ArrayExpr.elements ?? []).some(hasColumnReference);
+  }
+  if (node.SubLink !== void 0) {
+    return true;
+  }
+  return false;
+}
+
+function isParsedInsertResult(parsed) {
+  return parsed.stmts[0]?.stmt?.InsertStmt !== void 0;
+}
+function validateInsertResult(parsed, pgColsBySchemaAndTableName, query) {
+  const insertStmt = parsed.stmts[0].stmt.InsertStmt;
+  if (insertStmt.relation === void 0) {
+    return;
+  }
+  const schemaName = insertStmt.relation.schemaname ?? "public";
+  const tableName = insertStmt.relation.relname;
+  const tableCols = pgColsBySchemaAndTableName.get(schemaName)?.get(tableName);
+  if (tableCols === void 0) {
+    return;
+  }
+  const insertCols = getInsertColumns(insertStmt, tableCols);
+  const missing = tableCols.filter(
+    (c) => c.colNotNull && !c.colHasDef && c.colIdentity === "" && !insertCols.includes(c.colName)
+  );
+  if (missing.length === 0) {
+    return;
+  }
+  const position = (parsed.stmts[0]?.stmtLocation ?? 0) + 1;
+  const columnsStr = missing.map((c) => `"${c.colName}"`).join(", ");
+  const message = missing.length === 1 ? [
+    `null value in column ${columnsStr} violates not-null constraint`,
+    `Hint: Column ${columnsStr} is not nullable and has no default value.`
+  ].join("\n") : [
+    `null value in columns ${columnsStr} violates not-null constraint`,
+    `Hint: Columns ${columnsStr} are not nullable and have no default value.`
+  ].join("\n");
+  throw checkSql_utils.PostgresError.of({
+    queryText: query.text,
+    message,
+    line: "1",
+    position,
+    sourcemaps: query.sourcemaps
+  });
+}
+function getInsertColumns(stmt, tableCols) {
+  if (stmt.cols) {
+    return stmt.cols.map((col) => col.ResTarget?.name).filter((name) => Boolean(name));
+  }
+  if (stmt.selectStmt === void 0) {
+    return [];
+  }
+  const valuesFromSelect = stmt.selectStmt.SelectStmt?.valuesLists?.at(0)?.List?.items;
+  if (valuesFromSelect !== void 0) {
+    return tableCols.slice(0, valuesFromSelect.length).map((c) => c.colName);
+  }
+  return tableCols.map((c) => c.colName);
+}
+
+function createEmptyCache() {
+  return {
+    base: /* @__PURE__ */ new Map(),
+    overrides: {
+      types: /* @__PURE__ */ new Map(),
+      columns: /* @__PURE__ */ new Map()
+    },
+    functions: /* @__PURE__ */ new Map()
+  };
+}
+function createGenerator() {
+  const cache = createEmptyCache();
+  return {
+    generate: (params) => generate(params, cache),
+    dropCacheKey: (cacheKey) => cache.base.delete(cacheKey),
+    clearCache: () => {
+      cache.base.clear();
+      cache.overrides.types.clear();
+      cache.overrides.columns.clear();
+      cache.functions.clear();
+    }
+  };
+}
+async function generate(params, cache) {
+  const { sql, query, cacheKey, cacheMetadata = true } = params;
+  const {
+    pgColsByTableOidCache,
+    pgColsBySchemaAndTableName,
+    pgTypes,
+    pgEnums,
+    pgFnsByName,
+    pgTypeExprMap
+  } = await checkSql_utils.getOrSetFromMapWithEnabled({
+    shouldCache: cacheMetadata,
+    map: cache.base,
+    key: cacheKey,
+    value: () => getDatabaseMetadata(sql)
+  });
+  const typesMap = await checkSql_utils.getOrSetFromMapWithEnabled({
+    shouldCache: cacheMetadata,
+    map: cache.overrides.types,
+    key: JSON.stringify(params.overrides?.types),
+    value: () => {
+      const map = /* @__PURE__ */ new Map([["array", { override: false, value: "array" }]]);
+      for (const [key, value] of checkSql_utils.defaultTypesMap.entries()) {
+        map.set(key, { override: false, value });
+      }
+      for (const [k, v] of Object.entries(params.overrides?.types ?? {})) {
+        map.set(k, { override: true, value: typeof v === "string" ? v : v.return });
+      }
+      return map;
+    }
+  });
+  const overridenColumnTypesMap = await checkSql_utils.getOrSetFromMapWithEnabled({
+    shouldCache: cacheMetadata,
+    map: cache.overrides.columns,
+    key: JSON.stringify(params.overrides?.columns),
+    value: () => {
+      const map = /* @__PURE__ */ new Map();
+      for (const [colPath, type] of Object.entries(params.overrides?.columns ?? {})) {
+        const [table, column] = colPath.split(".");
+        if (table === void 0 || column === void 0) {
+          throw new Error(`Invalid override column key: ${colPath}. Expected format: table.column`);
+        }
+        map.has(table) ? map.get(table)?.set(column, type) : map.set(table, /* @__PURE__ */ new Map([[column, type]]));
+      }
+      return map;
+    }
+  });
+  function byReturnType(a, b) {
+    const priority = ["numeric", "int8"];
+    return priority.indexOf(a.returnType) - priority.indexOf(b.returnType);
+  }
+  const functionsMap = await checkSql_utils.getOrSetFromMapWithEnabled({
+    shouldCache: cacheMetadata,
+    map: cache.functions,
+    key: JSON.stringify(params.overrides?.types),
+    value: () => {
+      const map = /* @__PURE__ */ new Map();
+      for (const [functionName, signatures] of pgFnsByName.entries()) {
+        for (const signature of signatures.sort(byReturnType)) {
+          const tsArgs = signature.arguments.map((arg) => {
+            return typesMap.get(arg)?.value ?? "unknown";
+          });
+          const tsReturnType = typesMap.get(signature.returnType)?.value ?? signature.returnType;
+          const key = tsArgs.length === 0 ? functionName : `${functionName}(${tsArgs.join(", ")})`;
+          map.set(key, { ts: tsReturnType, pg: signature.returnType });
+        }
+      }
+      return map;
+    }
+  });
+  try {
+    const result = await sql.unsafe(query.text, [], { prepare: true }).describe();
+    const parsed = await parser__namespace.parse(query.text);
+    if (isParsedInsertResult(parsed)) {
+      validateInsertResult(parsed, pgColsBySchemaAndTableName, query);
+    }
+    if (result.columns === void 0 || result.columns === null || result.columns.length === 0) {
+      return fpTs.either.right({ output: null, unknownColumns: [], stmt: result, query });
+    }
+    const duplicateCols = result.columns.filter(
+      (col, index) => result.columns.find((c, i) => c.name === col.name && i != index)
+    );
+    if (duplicateCols.length > 0) {
+      const dupes = duplicateCols.map((col) => {
+        const tableCols = pgColsByTableOidCache.get(col.table);
+        const tableCol = col.number !== 0 ? tableCols?.at(col.number - 1) : tableCols?.find((c) => c.colName === col.name);
+        return {
+          table: tableCol?.tableName,
+          column: col.name,
+          originalColumn: tableCol?.colName
+        };
+      });
+      const dupePosition = (() => {
+        const match = query.text.search(new RegExp(`\\b${duplicateCols[0].name}\\b`));
+        return (match > -1 ? match : query.text.search(/SELECT/i)) + 1;
+      })();
+      return fpTs.either.left(
+        checkSql_utils.DuplicateColumnsError.of({
+          queryText: query.text,
+          sourcemaps: query.sourcemaps,
+          position: dupePosition,
+          columns: dupes.map((x) => {
+            return x.column !== x.originalColumn ? `${x.table}.${x.originalColumn} (alias: ${x.column})` : `${x.table}.${x.column}`;
+          })
+        })
+      );
+    }
+    const astQueryDescription = getASTDescription({
+      parsed,
+      typesMap,
+      overridenColumnTypesMap,
+      pgColsBySchemaAndTableName,
+      pgTypes,
+      pgEnums,
+      pgFns: functionsMap,
+      typeExprMap: pgTypeExprMap,
+      fieldTransform: params.fieldTransform
+    });
+    const columns = result.columns.map((col, position) => {
+      const introspected = pgColsByTableOidCache.get(col.table)?.find((x) => x.colNum === col.number);
+      const astDescribed = astQueryDescription.map.get(position);
+      return {
+        described: col,
+        astDescribed,
+        introspected,
+        isNonNullableBasedOnAST: astQueryDescription.meta.nonNullableColumns.has(col.name)
+      };
+    });
+    const context = {
+      columns,
+      pgTypes,
+      pgEnums,
+      relationsWithJoins: astQueryDescription.meta.relations,
+      overrides: {
+        types: typesMap,
+        columns: overridenColumnTypesMap
+      },
+      pgColsBySchemaAndTableName,
+      fieldTransform: params.fieldTransform
+    };
+    return fpTs.either.right({
+      output: getTypedColumnEntries({ context }),
+      unknownColumns: columns.filter((x) => x.astDescribed === void 0).map((x) => x.described.name),
+      stmt: result,
+      query
+    });
+  } catch (e) {
+    if (checkSql_utils.isPostgresError(e)) {
+      return fpTs.either.left(
+        checkSql_utils.PostgresError.of({
+          queryText: query.text,
+          sourcemaps: query.sourcemaps,
+          message: e.message,
+          line: e.line,
+          position: e.position
+        })
+      );
+    }
+    throw e;
+  }
+}
+async function getDatabaseMetadata(sql) {
+  const pgTypes = await getPgTypes(sql);
+  const pgCols = await getPgCols(sql);
+  const pgEnums = await getPgEnums(sql);
+  const pgFns = await getPgFunctions(sql);
+  const pgColsByTableOidCache = checkSql_utils.groupBy(pgCols, "tableOid");
+  const pgColsBySchemaAndTableName = checkSql_utils.groupBy(pgCols, "schemaName", "tableName");
+  const pgFnsByName = checkSql_utils.groupBy(pgFns, "name");
+  const pgTypeExprMap = await getPgTypeExprMap(sql);
+  return {
+    pgTypes,
+    pgCols,
+    pgEnums,
+    pgColsByTableOidCache,
+    pgColsBySchemaAndTableName,
+    pgFnsByName,
+    pgTypeExprMap
+  };
+}
+function getTypedColumnEntries(params) {
+  const value = params.context.columns.map(
+    (col) => getResolvedTargetEntry({ col, context: params.context })
+  );
+  return { kind: "object", value };
+}
+function isNullableResolvedTarget(target) {
+  switch (target.kind) {
+    case "type":
+      return ["any", "null"].includes(target.value) === false;
+    case "union":
+      return target.value.some(isNullableResolvedTarget);
+    case "array":
+      return isNullableResolvedTarget(target.value);
+    case "object":
+      return target.value.some(([, value]) => isNullableResolvedTarget(value));
+    case "literal":
+      return false;
+  }
+}
+function buildInterfacePropertyValue(params) {
+  const isNullable = params.isNullable && isNullableResolvedTarget(params.value);
+  return [
+    params.key,
+    isNullable ? { kind: "union", value: [params.value, { kind: "type", value: "null", type: "null" }] } : params.value
+  ];
+}
+function checkIsNullableDueToRelation(params) {
+  const { col, relationsWithJoins } = params;
+  const findByJoin = relationsWithJoins.find((x) => x.joinRelName === col.tableName);
+  if (findByJoin !== void 0) {
+    switch (findByJoin.joinType) {
+      case JoinType.JOIN_LEFT:
+      case JoinType.JOIN_FULL:
+        return true;
+      case JoinType.JOIN_TYPE_UNDEFINED:
+      case JoinType.JOIN_INNER:
+      case JoinType.JOIN_RIGHT:
+      case JoinType.JOIN_SEMI:
+      case JoinType.JOIN_ANTI:
+      case JoinType.JOIN_UNIQUE_OUTER:
+      case JoinType.JOIN_UNIQUE_INNER:
+      case JoinType.UNRECOGNIZED:
+        return false;
+      default:
+        checkSql_utils.assertNever(findByJoin.joinType);
+    }
+  }
+  const findByRel = relationsWithJoins.filter((x) => x.relName === col.tableName);
+  for (const rel of findByRel) {
+    switch (rel.joinType) {
+      case JoinType.JOIN_RIGHT:
+      case JoinType.JOIN_FULL:
+        return true;
+      case JoinType.JOIN_TYPE_UNDEFINED:
+      case JoinType.JOIN_INNER:
+      case JoinType.JOIN_LEFT:
+      case JoinType.JOIN_SEMI:
+      case JoinType.JOIN_ANTI:
+      case JoinType.JOIN_UNIQUE_OUTER:
+      case JoinType.JOIN_UNIQUE_INNER:
+      case JoinType.UNRECOGNIZED:
+        return false;
+      default:
+        checkSql_utils.assertNever(rel.joinType);
+    }
+  }
+  return false;
+}
+function getResolvedTargetEntry(params) {
+  if (params.col.astDescribed !== void 0) {
+    return [
+      checkSql_utils.toCase(params.col.described.name, params.context.fieldTransform),
+      params.col.astDescribed.type
+    ];
+  }
+  const pgTypeOid = params.col.introspected?.colBaseTypeOid ?? params.col.described.type;
+  const pgType = params.context.pgTypes.get(pgTypeOid);
+  const getEnumByOid = (oid) => {
+    const pgEnum = params.context.pgEnums.get(oid);
+    if (pgEnum === void 0) {
+      return void 0;
+    }
+    return {
+      kind: "union",
+      value: pgEnum.values.map(
+        (value2) => ({
+          kind: "type",
+          value: `'${value2}'`,
+          type: pgEnum.name
+        })
+      )
+    };
+  };
+  const valueAsEnum = (() => {
+    const enumTarget = getEnumByOid(pgTypeOid);
+    if (enumTarget !== void 0) {
+      return enumTarget;
+    }
+    if (pgType?.typelem !== void 0 && pgType.typelem !== 0) {
+      const elemEnumTarget = getEnumByOid(pgType.typelem);
+      if (elemEnumTarget !== void 0) {
+        return { kind: "array", value: elemEnumTarget };
+      }
+    }
+    return void 0;
+  })();
+  const valueAsType = getTsTypeFromPgTypeOid({
+    pgTypeOid,
+    pgTypes: params.context.pgTypes
+  });
+  const valueAsOverride = (() => {
+    const pgType2 = params.context.pgTypes.get(
+      params.col.introspected?.colTypeOid ?? params.col.described.type
+    );
+    if (!pgType2) return void 0;
+    const columnOverride = params?.context?.overrides?.columns.get(params.col.introspected?.tableName ?? "")?.get(params.col.introspected?.colName ?? params.col.described.name);
+    if (columnOverride !== void 0) {
+      return { kind: "type", value: columnOverride, type: pgType2.name };
+    }
+    const typeOverride = params?.context?.overrides?.types.get(pgType2.name);
+    if (typeOverride !== void 0) {
+      return {
+        kind: "type",
+        value: typeOverride.value,
+        type: pgType2.name
+      };
+    }
+    return void 0;
+  })();
+  const value = valueAsOverride ?? valueAsEnum ?? valueAsType;
+  const key = params.col.described.name ?? params.col.introspected?.colName;
+  let isNonNullable = params.col.isNonNullableBasedOnAST;
+  if (!isNonNullable && params.col.introspected !== void 0) {
+    isNonNullable = params.col.introspected.colNotNull;
+    if (checkIsNullableDueToRelation({
+      col: params.col.introspected,
+      relationsWithJoins: params.context.relationsWithJoins
+    })) {
+      isNonNullable = false;
+    }
+  }
+  return buildInterfacePropertyValue({
+    key: checkSql_utils.toCase(key, params.context.fieldTransform),
+    value,
+    isNullable: !isNonNullable
+  });
+}
+function getTsTypeFromPgTypeOid(params) {
+  const pgType = params.pgTypes.get(params.pgTypeOid);
+  if (pgType === void 0) {
+    return { kind: "type", value: "unknown", type: "unknown" };
+  }
+  return getTsTypeFromPgType({ pgTypeName: pgType.name });
+}
+function getTsTypeFromPgType(params) {
+  const { isArray, pgType } = parsePgType(params.pgTypeName);
+  const tsType = checkSql_utils.defaultTypesMap.get(pgType) ?? "any";
+  const property = { kind: "type", value: tsType, type: pgType };
+  return isArray ? { kind: "array", value: property } : property;
+}
+function isPgTypeArray(pgType) {
+  return pgType.startsWith("_");
+}
+function parsePgType(pgType) {
+  const isArray = isPgTypeArray(pgType);
+  return {
+    isArray,
+    pgType: isArray ? pgType.slice(1) : pgType
+  };
+}
+async function getPgEnums(sql) {
+  const rows = await sql`
+    SELECT pg_type.oid, pg_type.typname, pg_enum.enumlabel
+    FROM pg_type
+    JOIN pg_enum ON pg_enum.enumtypid = pg_type.oid
+    WHERE pg_type.typtype = 'e'
+    ORDER BY pg_type.typname, pg_enum.enumsortorder
+  `;
+  const map = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const existing = map.get(row.oid);
+    if (existing === void 0) {
+      map.set(row.oid, {
+        name: row.typname,
+        values: [row.enumlabel]
+      });
+      continue;
+    }
+    existing.values.push(row.enumlabel);
+  }
+  return map;
+}
+async function getPgTypes(sql) {
+  const rows = await sql`
+        SELECT oid, typname as name, typelem FROM pg_type
+    `;
+  const map = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    map.set(row.oid, row);
+  }
+  return map;
+}
+async function getPgCols(sql) {
+  const rows = await sql`
+      SELECT
+          pg_class.oid AS "tableOid",
+          pg_namespace.nspname AS "schemaName",
+          pg_class.relname AS "tableName",
+          pg_attribute.attname AS "colName",
+          pg_type.oid AS "colTypeOid",
+          CASE
+              WHEN pg_type.typtype = 'd' THEN
+                  (SELECT pt.oid FROM pg_type pt WHERE pt.oid = pg_type.typbasetype)
+              ELSE
+                  NULL
+          END AS "colBaseTypeOid",
+          pg_attribute.attnum AS "colNum",
+          pg_attribute.atthasdef "colHasDef",
+          pg_attribute.attnotnull "colNotNull",
+          pg_attribute.attidentity "colIdentity"
+      FROM
+          pg_attribute,
+          pg_class,
+          pg_type,
+          pg_namespace
+      WHERE TRUE
+          AND pg_attribute.attrelid = pg_class.oid
+          AND pg_attribute.atttypid = pg_type.oid
+          AND pg_class.relnamespace = pg_namespace.oid
+          AND pg_attribute.attnum >= 1
+      ORDER BY
+          pg_class.relname,
+          pg_attribute.attnum
+  `;
+  return rows;
+}
+async function getPgFunctions(sql) {
+  const rows = await sql`
+      SELECT
+          pg_proc.proname AS "name",
+          pg_catalog.pg_get_function_arguments(pg_proc.oid) AS "argumentsString",
+          pg_type.typname AS "returnType"
+      FROM
+          pg_catalog.pg_proc
+      JOIN
+          pg_catalog.pg_type ON pg_proc.prorettype = pg_type.oid
+      WHERE
+          pg_proc.pronamespace::regnamespace = 'pg_catalog'::regnamespace
+  `;
+  return rows.map((row) => ({
+    name: row.name,
+    arguments: row.argumentsString.replace(/"/, "").split(", ").filter((x) => x !== ""),
+    returnType: row.returnType
+  }));
+}
+async function getPgTypeExprMap(sql) {
+  const rows = await sql`
+      SELECT
+        l.typname as left,
+        o.oprname as operator,
+        r.typname as right,
+        ret.typname AS result
+      FROM pg_operator o
+        JOIN pg_type l ON l.oid = o.oprleft
+        JOIN pg_type r ON r.oid = o.oprright
+        JOIN pg_type ret ON ret.oid = o.oprresult
+      WHERE o.oprleft <> 0 AND o.oprright <> 0
+  `;
+  const map = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const leftMap = map.get(row.left) ?? /* @__PURE__ */ new Map();
+    const rightMap = leftMap.get(row.operator) ?? /* @__PURE__ */ new Map();
+    rightMap.set(row.right, row.result);
+    leftMap.set(row.operator, rightMap);
+    map.set(row.left, leftMap);
+  }
+  return map;
+}
+
+function createConnectionManager() {
+  const connectionMap = /* @__PURE__ */ new Map();
+  return {
+    getOrCreate: (databaseUrl, options) => getOrCreateConnection(databaseUrl, connectionMap, options),
+    close: (params) => closeConnection(params, connectionMap)
+  };
+}
+function getOrCreateConnection(databaseUrl, connectionMap, options) {
+  return function_js.pipe(
+    O__namespace.fromNullable(connectionMap.get(databaseUrl)),
+    O__namespace.foldW(
+      () => {
+        const sql = postgres__default(databaseUrl, options);
+        connectionMap.set(databaseUrl, sql);
+        return { sql, databaseUrl, isFirst: true };
+      },
+      (sql) => ({ sql, databaseUrl, isFirst: false })
+    )
+  );
+}
+function closeConnection(params, connectionMap) {
+  const { connection, projectDir } = params;
+  const strategy = checkSql_utils.getConnectionStrategyByRuleOptionConnection({ connection, projectDir });
+  tsPattern.match(strategy).with({ type: "databaseUrl" }, ({ databaseUrl }) => {
+    const sql = connectionMap.get(databaseUrl);
+    if (sql) {
+      sql.end();
+      connectionMap.delete(databaseUrl);
+    }
+  }).with({ type: "migrations" }, ({ connectionUrl, databaseName }) => {
+    const connectionOptions = { ...checkSql_utils.parseConnection(connectionUrl), database: databaseName };
+    const databaseUrl = checkSql_utils.mapConnectionOptionsToString(connectionOptions);
+    const sql = connectionMap.get(databaseUrl);
+    const migrationSql = connectionMap.get(connectionUrl);
+    if (sql) {
+      sql.end();
+      connectionMap.delete(databaseUrl);
+    }
+    if (migrationSql) {
+      migrationSql.end();
+      connectionMap.delete(connectionUrl);
+    }
+  }).exhaustive();
+}
+
+function createWatchManager() {
+  const migrationPaths = /* @__PURE__ */ new Map();
+  const watcher = chokidar__default.watch([], { ignoreInitial: true }).on("all", (_, filePath) => {
+    for (const [path2, { onChange }] of migrationPaths.entries()) {
+      if (filePath.startsWith(path2)) {
+        return onChange();
+      }
+    }
+  });
+  const watchMigrationsDir = (params) => {
+    const migrationPath = path__default.join(params.projectDir, params.connection.migrationsDir);
+    if (migrationPaths.has(migrationPath)) {
+      return;
+    }
+    migrationPaths.set(migrationPath, {
+      onChange: () => {
+        const { databaseUrl } = checkSql_utils.getMigrationDatabaseMetadata({
+          connectionUrl: params.connection.connectionUrl ?? checkSql_utils.DEFAULT_CONNECTION_URL,
+          databaseName: checkSql_utils.getDatabaseName({
+            databaseName: params.connection.databaseName,
+            migrationsDir: params.connection.migrationsDir,
+            projectDir: params.projectDir
+          })
+        });
+        params.dropCacheKeyFn(databaseUrl);
+        params.closeConnectionFn({ connection: params.connection, projectDir: params.projectDir });
+      }
+    });
+    watcher.add(migrationPath);
+  };
+  return {
+    watchMigrationsDir
+  };
+}
+
+const generator = createGenerator();
+const connections = createConnectionManager();
+const watchers = createWatchManager();
+async function handler(params) {
+  if (checkSql_utils.isWatchMigrationsDirEnabled(params.connection)) {
+    watchers.watchMigrationsDir({
+      connection: params.connection,
+      projectDir: params.projectDir,
+      dropCacheKeyFn: generator.dropCacheKey,
+      closeConnectionFn: connections.close
+    });
+  }
+  const result = await function_js.pipe(
+    TE__namespace.Do,
+    TE__namespace.chain(() => workerHandler(params))
+  )();
+  if (params.connection.keepAlive === false) {
+    connections.close({ connection: params.connection, projectDir: params.projectDir });
+  }
+  return J__namespace.stringify(result);
+}
+synckit.runAsWorker(handler);
+function workerHandler(params) {
+  const strategy = checkSql_utils.getConnectionStrategyByRuleOptionConnection(params);
+  const connectionPayload = tsPattern.match(strategy).with(
+    { type: "databaseUrl" },
+    ({ databaseUrl }) => TE__namespace.right(connections.getOrCreate(databaseUrl))
+  ).with({ type: "migrations" }, ({ migrationsDir, databaseName, connectionUrl }) => {
+    const { connectionOptions, databaseUrl } = checkSql_utils.getMigrationDatabaseMetadata({
+      connectionUrl,
+      databaseName
+    });
+    const { sql, isFirst } = connections.getOrCreate(databaseUrl);
+    const { sql: migrationSql } = connections.getOrCreate(connectionUrl, {
+      onnotice: () => {
+      }
+    });
+    const connectionPayload2 = { sql, isFirst, databaseUrl };
+    if (isFirst) {
+      const migrationsPath = path__default.join(params.projectDir, migrationsDir);
+      return function_js.pipe(
+        TE__namespace.Do,
+        TE__namespace.chainW(() => checkSql_utils.initDatabase(migrationSql, connectionOptions.database)),
+        TE__namespace.chainW(() => checkSql_utils.runMigrations({ migrationsPath, sql })),
+        TE__namespace.map(() => connectionPayload2)
+      );
+    }
+    return TE__namespace.right(connectionPayload2);
+  }).exhaustive();
+  const generateTask = (params2) => {
+    return TE__namespace.tryCatch(() => generator.generate(params2), checkSql_utils.InternalError.to);
+  };
+  return function_js.pipe(
+    connectionPayload,
+    TE__namespace.chainW(({ sql, databaseUrl }) => {
+      return generateTask({
+        sql,
+        query: params.query,
+        cacheKey: databaseUrl,
+        overrides: params.connection.overrides,
+        fieldTransform: params.target.fieldTransform
+      });
+    }),
+    TE__namespace.chainW(TE__namespace.fromEither)
+  );
+}
+//# sourceMappingURL=check-sql.worker.cjs.map