eslint-plugin-slonik 1.0.0

package/dist/shared/eslint-plugin-slonik.BxexVlk1.cjs

@@ -0,0 +1,1539 @@
+'use strict';
+
+const checkSql_utils = require('./eslint-plugin-slonik.rlOTrCdf.cjs');
+const utils = require('@typescript-eslint/utils');
+const tsPattern = require('ts-pattern');
+const E = require('fp-ts/lib/Either.js');
+const function_js = require('fp-ts/lib/function.js');
+require('fp-ts/lib/Option.js');
+require('fp-ts/lib/TaskEither.js');
+const J = require('fp-ts/lib/Json.js');
+const ts = require('typescript');
+const path = require('path');
+const fs = require('fs');
+const synckit = require('synckit');
+const node_url = require('node:url');
+const z = require('zod');
+const module$1 = require('module');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+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 E__namespace = /*#__PURE__*/_interopNamespaceCompat(E);
+const J__namespace = /*#__PURE__*/_interopNamespaceCompat(J);
+const ts__default = /*#__PURE__*/_interopDefaultCompat(ts);
+const path__default = /*#__PURE__*/_interopDefaultCompat(path);
+const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+const z__default = /*#__PURE__*/_interopDefaultCompat(z);
+
+const PRIMITIVES = {
+  string: "string",
+  number: "number",
+  boolean: "boolean",
+  false: "false",
+  true: "true",
+  null: "null",
+  undefined: "undefined",
+  any: "any"
+};
+function getResolvedTargetByTypeNode(params) {
+  const typeText = params.parser.esTreeNodeToTSNodeMap.get(params.typeNode).getText();
+  if (isReservedType(typeText, params.reservedTypes)) {
+    return { kind: "type", value: typeText };
+  }
+  switch (params.typeNode.type) {
+    case utils.TSESTree.AST_NODE_TYPES.TSLiteralType:
+      return handleLiteralType(params.typeNode);
+    case utils.TSESTree.AST_NODE_TYPES.TSUnionType:
+      return {
+        kind: "union",
+        value: params.typeNode.types.map(
+          (type) => getResolvedTargetByTypeNode({ ...params, typeNode: type })
+        )
+      };
+    case utils.TSESTree.AST_NODE_TYPES.TSNullKeyword:
+      return { kind: "type", value: "null" };
+    case utils.TSESTree.AST_NODE_TYPES.TSUndefinedKeyword:
+      return { kind: "type", value: "undefined" };
+    case utils.TSESTree.AST_NODE_TYPES.TSTypeLiteral:
+      return handleTypeLiteral(params.typeNode, params);
+    case utils.TSESTree.AST_NODE_TYPES.TSTypeReference:
+      return handleTypeReference(params.typeNode, params);
+    case utils.TSESTree.AST_NODE_TYPES.TSIntersectionType:
+      return handleIntersectionType(params.typeNode, params);
+    case utils.TSESTree.AST_NODE_TYPES.TSArrayType:
+      return {
+        kind: "array",
+        value: getResolvedTargetByTypeNode({
+          ...params,
+          typeNode: params.typeNode.elementType
+        })
+      };
+    default:
+      return { kind: "type", value: typeText };
+  }
+}
+function isReservedType(typeText, reservedTypes) {
+  return reservedTypes.has(typeText) || reservedTypes.has(`${typeText}[]`);
+}
+function handleLiteralType(typeNode) {
+  return typeNode.literal.type === utils.TSESTree.AST_NODE_TYPES.Literal ? { kind: "type", value: `'${typeNode.literal.value}'` } : { kind: "type", value: "unknown" };
+}
+function handleTypeLiteral(typeNode, params) {
+  const properties = typeNode.members.flatMap((member) => {
+    if (member.type !== utils.TSESTree.AST_NODE_TYPES.TSPropertySignature || !member.typeAnnotation) {
+      return [];
+    }
+    const key = extractPropertyKey(member.key);
+    if (!key) return [];
+    const propertyName = member.optional ? `${key}?` : key;
+    const propertyType = getResolvedTargetByTypeNode({
+      ...params,
+      typeNode: member.typeAnnotation.typeAnnotation
+    });
+    return [[propertyName, propertyType]];
+  });
+  return { kind: "object", value: properties };
+}
+function extractPropertyKey(key) {
+  switch (key.type) {
+    case utils.TSESTree.AST_NODE_TYPES.Identifier:
+      return key.name;
+    case utils.TSESTree.AST_NODE_TYPES.Literal:
+      return String(key.value);
+    default:
+      return void 0;
+  }
+}
+function handleTypeReference(typeNode, params) {
+  if (typeNode.typeName.type !== utils.TSESTree.AST_NODE_TYPES.Identifier && typeNode.typeName.type !== utils.TSESTree.AST_NODE_TYPES.TSQualifiedName) {
+    return { kind: "type", value: "unknown" };
+  }
+  const typeNameText = params.parser.esTreeNodeToTSNodeMap.get(typeNode.typeName).getText();
+  if (params.reservedTypes.has(typeNameText)) {
+    return { kind: "type", value: typeNameText };
+  }
+  if (typeNameText === "Array" && typeNode.typeArguments?.params[0]) {
+    return {
+      kind: "array",
+      syntax: "type-reference",
+      value: getResolvedTargetByTypeNode({
+        ...params,
+        typeNode: typeNode.typeArguments.params[0]
+      })
+    };
+  }
+  const type = params.checker.getTypeFromTypeNode(
+    params.parser.esTreeNodeToTSNodeMap.get(typeNode)
+  );
+  return resolveType(type, { ...params, typeNode });
+}
+function handleIntersectionType(typeNode, params) {
+  const allProperties = typeNode.types.flatMap((type) => {
+    const resolved = getResolvedTargetByTypeNode({ ...params, typeNode: type });
+    return resolved.kind === "object" ? resolved.value : [];
+  });
+  return { kind: "object", value: Array.from(new Map(allProperties).entries()) };
+}
+function resolveType(type, params) {
+  const typeAsString = params.checker.typeToString(type);
+  if (params.reservedTypes.has(typeAsString)) {
+    return { kind: "type", value: typeAsString };
+  }
+  if (params.reservedTypes.has(`${typeAsString}[]`)) {
+    return { kind: "array", value: { kind: "type", value: typeAsString.replace("[]", "") } };
+  }
+  const primitive = getPrimitiveType(type, typeAsString);
+  if (primitive) return primitive;
+  if (type.isLiteral()) {
+    return { kind: "type", value: `'${type.value}'` };
+  }
+  if (type.isUnion()) {
+    return handleUnionTypeReference(type, params);
+  }
+  if (type.isIntersection()) {
+    return handleIntersectionTypeReference(type, params);
+  }
+  if (params.checker.isArrayType(type)) {
+    return handleArrayTypeReferenceFromType(type, params);
+  }
+  return handleObjectType(type, params);
+}
+function getPrimitiveType(type, typeAsString) {
+  if (PRIMITIVES[typeAsString]) {
+    return { kind: "type", value: PRIMITIVES[typeAsString] };
+  }
+  const flagMap = {
+    [ts__default.TypeFlags.String]: "string",
+    [ts__default.TypeFlags.Number]: "number",
+    [ts__default.TypeFlags.Boolean]: "boolean",
+    [ts__default.TypeFlags.Null]: "null",
+    [ts__default.TypeFlags.Undefined]: "undefined",
+    [ts__default.TypeFlags.Any]: "any"
+  };
+  return flagMap[type.flags] ? { kind: "type", value: flagMap[type.flags] } : null;
+}
+function handleUnionTypeReference(type, params) {
+  const types = type.types.map((t) => resolveType(t, params));
+  const isBooleanUnionWithNull = types.length === 3 && types.some((t) => t.value === "false") && types.some((t) => t.value === "true") && types.some((t) => t.value === "null");
+  if (isBooleanUnionWithNull) {
+    return {
+      kind: "union",
+      value: [
+        { kind: "type", value: "boolean" },
+        { kind: "type", value: "null" }
+      ]
+    };
+  }
+  return { kind: "union", value: types };
+}
+function handleIntersectionTypeReference(type, params) {
+  const properties = type.types.flatMap((t) => {
+    const resolved = resolveType(t, params);
+    return resolved.kind === "object" ? resolved.value : [];
+  });
+  return { kind: "object", value: properties };
+}
+function handleArrayTypeReferenceFromType(type, params) {
+  const typeArguments = type.typeArguments;
+  const firstArgument = typeArguments?.[0];
+  if (firstArgument) {
+    const elementType = resolveType(firstArgument, params);
+    return { kind: "array", value: elementType };
+  }
+  return { kind: "array", value: { kind: "type", value: "unknown" } };
+}
+function handleObjectType(type, params) {
+  if (!type.symbol) {
+    return { kind: "type", value: type.aliasSymbol?.escapedName.toString() ?? "unknown" };
+  }
+  if (type.symbol.valueDeclaration) {
+    const declaration = type.symbol.valueDeclaration;
+    const sourceFile = declaration.getSourceFile();
+    const filePath = sourceFile.fileName;
+    if (!filePath.includes("node_modules")) {
+      return extractObjectProperties(type, params);
+    }
+    return { kind: "type", value: type.symbol.name };
+  }
+  if (type.flags === ts__default.TypeFlags.Object) {
+    return extractObjectProperties(type, params);
+  }
+  return { kind: "object", value: [] };
+}
+function extractObjectProperties(type, params) {
+  const properties = type.getProperties().map((property) => {
+    const key = property.escapedName.toString();
+    const propType = params.checker.getTypeOfSymbolAtLocation(
+      property,
+      params.parser.esTreeNodeToTSNodeMap.get(params.typeNode)
+    );
+    const resolvedType = resolveType(propType, params);
+    return [key, resolvedType];
+  });
+  return { kind: "object", value: properties };
+}
+
+function isInEditorEnv() {
+  if (process.env.CI) return false;
+  if (isInGitHooksOrLintStaged()) return false;
+  return !!(process.env.VSCODE_PID || process.env.VSCODE_CWD || process.env.JETBRAINS_IDE || process.env.VIM || process.env.NVIM);
+}
+function isInGitHooksOrLintStaged() {
+  return !!(process.env.GIT_PARAMS || process.env.VSCODE_GIT_COMMAND || process.env.npm_lifecycle_script?.startsWith("lint-staged"));
+}
+
+const memoized = /* @__PURE__ */ new Map();
+function memoize(params) {
+  const { key, value } = params;
+  if (memoized.has(key)) {
+    return memoized.get(key);
+  }
+  const result = value();
+  memoized.set(key, result);
+  return result;
+}
+
+function locateNearestPackageJsonDir(filePath) {
+  const dir = path__default.dirname(filePath);
+  const packageJsonFile = path__default.join(dir, "package.json");
+  if (fs__default.existsSync(packageJsonFile)) {
+    return dir;
+  }
+  return locateNearestPackageJsonDir(dir);
+}
+
+const TSUtils = {
+  isTypeUnion: (typeNode) => {
+    return typeNode?.kind === ts__default.SyntaxKind.UnionType;
+  },
+  isTsUnionType(type) {
+    return type.flags === ts__default.TypeFlags.Union;
+  },
+  isTsTypeReference(type) {
+    return TSUtils.isTsObjectType(type) && type.objectFlags === ts__default.ObjectFlags.Reference;
+  },
+  isTsArrayUnionType(checker, type) {
+    if (!TSUtils.isTsTypeReference(type)) {
+      return false;
+    }
+    const firstArgument = checker.getTypeArguments(type)[0];
+    if (firstArgument === void 0) {
+      return false;
+    }
+    return TSUtils.isTsUnionType(firstArgument);
+  },
+  isTsObjectType(type) {
+    return type.flags === ts__default.TypeFlags.Object;
+  },
+  getEnumKind(type) {
+    const symbol = type.getSymbol();
+    if (!symbol || !(symbol.flags & ts__default.SymbolFlags.Enum)) {
+      return void 0;
+    }
+    const declarations = symbol.getDeclarations();
+    if (!declarations) {
+      return void 0;
+    }
+    let hasString = false;
+    let hasNumeric = false;
+    const stringValues = [];
+    for (const declaration of declarations) {
+      if (ts__default.isEnumDeclaration(declaration)) {
+        for (const member of declaration.members) {
+          const initializer = member.initializer;
+          if (initializer) {
+            if (ts__default.isStringLiteralLike(initializer)) {
+              hasString = true;
+              stringValues.push(initializer.text);
+            }
+            if (initializer.kind === ts__default.SyntaxKind.NumericLiteral) {
+              hasNumeric = true;
+            }
+          } else {
+            hasNumeric = true;
+          }
+        }
+      }
+    }
+    if (symbol.flags & ts__default.SymbolFlags.ConstEnum) {
+      return { kind: "Const" };
+    }
+    if (hasString && hasNumeric) {
+      return { kind: "Heterogeneous" };
+    }
+    if (hasString) {
+      return { kind: "String", values: stringValues };
+    }
+    return { kind: "Numeric" };
+  }
+};
+
+const keywords = [
+  "WITH",
+  "SELECT",
+  "FROM",
+  "WHERE",
+  "GROUP BY",
+  "HAVING",
+  "WINDOW",
+  "ORDER BY",
+  "PARTITION BY",
+  "LIMIT",
+  "OFFSET",
+  "INSERT INTO",
+  "VALUES",
+  "UPDATE",
+  "SET",
+  "RETURNING",
+  "ON",
+  "JOIN",
+  "INNER JOIN",
+  "LEFT JOIN",
+  "RIGHT JOIN",
+  "FULL JOIN",
+  "FULL OUTER JOIN",
+  "CROSS JOIN",
+  "WHEN",
+  "USING",
+  "UNION",
+  "UNION ALL",
+  "INTERSECT",
+  "EXCEPT"
+];
+const keywordSet = new Set(keywords);
+function isLastQueryContextOneOf(queryText, keywords2) {
+  const contextKeywords = getLastQueryContext(queryText);
+  const lastKeyword = contextKeywords[contextKeywords.length - 1];
+  return keywords2.some((keyword) => keyword === lastKeyword);
+}
+function getLastQueryContext(queryText) {
+  const context = getQueryContext(queryText);
+  const iterate = (ctx) => {
+    const last = ctx[ctx.length - 1];
+    if (Array.isArray(last)) {
+      return iterate(last);
+    }
+    return ctx;
+  };
+  return iterate(context);
+}
+function getQueryContext(queryText) {
+  const tokens = removePgComments(queryText).split(/(\s+|\(|\))/).filter((token) => token.trim() !== "");
+  let index = 0;
+  function parseQuery() {
+    const context = [];
+    while (index < tokens.length) {
+      const token = tokens[index++].toUpperCase();
+      if (token === ")") {
+        return context;
+      }
+      if (token === "(") {
+        const subquery = parseQuery();
+        if (subquery.length > 0) {
+          context.push(subquery);
+        }
+        continue;
+      }
+      const previousToken = tokens[index - 2]?.toUpperCase();
+      const nextToken = tokens[index]?.toUpperCase();
+      if (isOneOf(["ORDER", "GROUP", "PARTITION"], token) && nextToken === "BY") {
+        index++;
+        context.push(`${token} BY`);
+        continue;
+      }
+      if (token === "JOIN") {
+        switch (previousToken) {
+          case "INNER":
+          case "LEFT":
+          case "RIGHT":
+          case "FULL":
+          case "CROSS":
+            context.push(`${previousToken} JOIN`);
+            break;
+          case "OUTER":
+            context.push("FULL OUTER JOIN");
+            break;
+        }
+        continue;
+      }
+      if (keywordSet.has(token)) {
+        context.push(token);
+        continue;
+      }
+    }
+    return context;
+  }
+  return parseQuery();
+}
+function removePgComments(query) {
+  return query.replace(/--.*(\r?\n|$)|\/\*[\s\S]*?\*\//g, "").trim();
+}
+function isOneOf(values, value) {
+  return values.includes(value);
+}
+
+const SLONIK_SQL_TOKEN_TYPES = /* @__PURE__ */ new Set([
+  // Core SQL tokens from Slonik
+  "SqlToken",
+  "SqlSqlToken",
+  "QuerySqlToken",
+  "FragmentSqlToken",
+  "SqlFragmentToken",
+  "SqlFragment",
+  // Return type of sql.fragment
+  "ListSqlToken",
+  "UnnestSqlToken",
+  "IdentifierSqlToken",
+  "ArraySqlToken",
+  "JsonSqlToken",
+  "JsonBinarySqlToken",
+  "BinarySqlToken",
+  "DateSqlToken",
+  "TimestampSqlToken",
+  "IntervalSqlToken",
+  "UuidSqlToken",
+  // Return type of sql.uuid
+  // Generic/union types
+  "PrimitiveValueExpression",
+  "ValueExpression",
+  "SqlTokenType"
+]);
+function isSlonikSqlTokenType(typeStr) {
+  if (SLONIK_SQL_TOKEN_TYPES.has(typeStr)) {
+    return true;
+  }
+  for (const tokenType of SLONIK_SQL_TOKEN_TYPES) {
+    if (typeStr.includes(tokenType)) {
+      return true;
+    }
+  }
+  return false;
+}
+function extractSlonikArrayType(expression) {
+  if (expression.type !== "CallExpression") {
+    return null;
+  }
+  const callee = expression.callee;
+  if (callee.type !== "MemberExpression") {
+    return null;
+  }
+  if (callee.property.type !== "Identifier" || callee.property.name !== "array") {
+    return null;
+  }
+  const objectName = getMemberExpressionObjectName(callee.object);
+  if (objectName !== "sql") {
+    return null;
+  }
+  const typeArg = expression.arguments[1];
+  if (!typeArg) {
+    return null;
+  }
+  if (typeArg.type === "Literal" && typeof typeArg.value === "string") {
+    return `${typeArg.value}[]`;
+  }
+  return null;
+}
+function getMemberExpressionObjectName(node) {
+  if (node.type === "Identifier") {
+    return node.name;
+  }
+  if (node.type === "MemberExpression" && node.object.type === "ThisExpression" && node.property.type === "Identifier") {
+    return node.property.name;
+  }
+  return null;
+}
+function extractSlonikIdentifier(expression) {
+  if (expression.type !== "CallExpression") {
+    return null;
+  }
+  const callee = expression.callee;
+  if (callee.type !== "MemberExpression") {
+    return null;
+  }
+  if (callee.property.type !== "Identifier" || callee.property.name !== "identifier") {
+    return null;
+  }
+  const objectName = getMemberExpressionObjectName(callee.object);
+  if (objectName !== "sql") {
+    return null;
+  }
+  const partsArg = expression.arguments[0];
+  if (!partsArg) {
+    return null;
+  }
+  if (partsArg.type === "ArrayExpression") {
+    const parts = [];
+    for (const element of partsArg.elements) {
+      if (element && element.type === "Literal" && typeof element.value === "string") {
+        parts.push(element.value);
+      } else {
+        return null;
+      }
+    }
+    if (parts.length === 0) {
+      return null;
+    }
+    return parts.map((part) => `"${part}"`).join(".");
+  }
+  return null;
+}
+function isSlonikJoinCall(expression) {
+  if (expression.type !== "CallExpression") {
+    return false;
+  }
+  const callee = expression.callee;
+  if (callee.type !== "MemberExpression") {
+    return false;
+  }
+  if (callee.property.type !== "Identifier" || callee.property.name !== "join") {
+    return false;
+  }
+  const objectName = getMemberExpressionObjectName(callee.object);
+  return objectName === "sql";
+}
+function extractSlonikFragment(expression) {
+  if (expression.type !== "TaggedTemplateExpression") {
+    return null;
+  }
+  const tag = expression.tag;
+  if (tag.type !== "MemberExpression") {
+    return null;
+  }
+  if (tag.property.type !== "Identifier" || tag.property.name !== "fragment") {
+    return null;
+  }
+  const objectName = getMemberExpressionObjectName(tag.object);
+  if (objectName !== "sql") {
+    return null;
+  }
+  const quasi = expression.quasi;
+  let sqlText = "";
+  const nestedExpressions = [];
+  for (const [i, templateElement] of quasi.quasis.entries()) {
+    sqlText += templateElement.value.raw;
+    if (!templateElement.tail && quasi.expressions[i]) {
+      nestedExpressions.push(quasi.expressions[i]);
+      sqlText += `\${__FRAGMENT_EXPR_${nestedExpressions.length - 1}__}`;
+    }
+  }
+  return { sqlText, expressions: nestedExpressions };
+}
+function extractSlonikUnnestTypes(expression) {
+  if (expression.type !== "CallExpression") {
+    return null;
+  }
+  const callee = expression.callee;
+  if (callee.type !== "MemberExpression") {
+    return null;
+  }
+  if (callee.property.type !== "Identifier" || callee.property.name !== "unnest") {
+    return null;
+  }
+  const objectName = getMemberExpressionObjectName(callee.object);
+  if (objectName !== "sql") {
+    return null;
+  }
+  const typeArg = expression.arguments[1];
+  if (!typeArg) {
+    return null;
+  }
+  if (typeArg.type === "ArrayExpression") {
+    const types = [];
+    for (const element of typeArg.elements) {
+      if (element && element.type === "Literal" && typeof element.value === "string") {
+        types.push(`${element.value}[]`);
+      } else {
+        return null;
+      }
+    }
+    return types.length > 0 ? types : null;
+  }
+  return null;
+}
+function mapTemplateLiteralToQueryText(quasi, parser, checker, options, sourceCode) {
+  let $idx = 0;
+  let $queryText = "";
+  const sourcemaps = [];
+  for (const [quasiIdx, $quasi] of quasi.quasis.entries()) {
+    $queryText += $quasi.value.raw;
+    if ($quasi.tail) {
+      break;
+    }
+    const position = $queryText.length;
+    const expression = quasi.expressions[quasiIdx];
+    const slonikArrayType = extractSlonikArrayType(expression);
+    if (slonikArrayType !== null) {
+      const placeholder2 = `$${++$idx}::${slonikArrayType}`;
+      $queryText += placeholder2;
+      sourcemaps.push({
+        original: {
+          start: expression.range[0] - quasi.range[0] - 2,
+          end: expression.range[1] - quasi.range[0],
+          text: sourceCode.text.slice(expression.range[0] - 2, expression.range[1] + 1)
+        },
+        generated: {
+          start: position,
+          end: position + placeholder2.length,
+          text: placeholder2
+        },
+        offset: 0
+      });
+      continue;
+    }
+    const slonikIdentifier = extractSlonikIdentifier(expression);
+    if (slonikIdentifier !== null) {
+      $queryText += slonikIdentifier;
+      sourcemaps.push({
+        original: {
+          start: expression.range[0] - quasi.range[0] - 2,
+          end: expression.range[1] - quasi.range[0],
+          text: sourceCode.text.slice(expression.range[0] - 2, expression.range[1] + 1)
+        },
+        generated: {
+          start: position,
+          end: position + slonikIdentifier.length,
+          text: slonikIdentifier
+        },
+        offset: 0
+      });
+      continue;
+    }
+    if (isSlonikJoinCall(expression)) {
+      const placeholder2 = `$${++$idx}`;
+      $queryText += placeholder2;
+      sourcemaps.push({
+        original: {
+          start: expression.range[0] - quasi.range[0] - 2,
+          end: expression.range[1] - quasi.range[0],
+          text: sourceCode.text.slice(expression.range[0] - 2, expression.range[1] + 1)
+        },
+        generated: {
+          start: position,
+          end: position + placeholder2.length,
+          text: placeholder2
+        },
+        offset: 0
+      });
+      continue;
+    }
+    const slonikUnnestTypes = extractSlonikUnnestTypes(expression);
+    if (slonikUnnestTypes !== null) {
+      const placeholders = slonikUnnestTypes.map((type) => `$${++$idx}::${type}`);
+      const placeholder2 = `unnest(${placeholders.join(", ")})`;
+      $queryText += placeholder2;
+      sourcemaps.push({
+        original: {
+          start: expression.range[0] - quasi.range[0] - 2,
+          end: expression.range[1] - quasi.range[0],
+          text: sourceCode.text.slice(expression.range[0] - 2, expression.range[1] + 1)
+        },
+        generated: {
+          start: position,
+          end: position + placeholder2.length,
+          text: placeholder2
+        },
+        offset: 0
+      });
+      continue;
+    }
+    const slonikFragment = extractSlonikFragment(expression);
+    if (slonikFragment !== null) {
+      let fragmentSql = slonikFragment.sqlText;
+      for (let i = 0; i < slonikFragment.expressions.length; i++) {
+        const nestedExpr = slonikFragment.expressions[i];
+        const nestedPgType = function_js.pipe(
+          mapExpressionToTsTypeString({ expression: nestedExpr, parser, checker }),
+          (params) => getPgTypeFromTsType({ ...params, checker, options })
+        );
+        let nestedPlaceholder;
+        if (E__namespace.isLeft(nestedPgType) || nestedPgType.right === null) {
+          nestedPlaceholder = `$${++$idx}`;
+        } else if (nestedPgType.right.kind === "literal") {
+          nestedPlaceholder = nestedPgType.right.value;
+        } else {
+          nestedPlaceholder = `$${++$idx}::${nestedPgType.right.cast}`;
+        }
+        fragmentSql = fragmentSql.replace(`\${__FRAGMENT_EXPR_${i}__}`, nestedPlaceholder);
+      }
+      $queryText += fragmentSql;
+      sourcemaps.push({
+        original: {
+          start: expression.range[0] - quasi.range[0] - 2,
+          end: expression.range[1] - quasi.range[0],
+          text: sourceCode.text.slice(expression.range[0] - 2, expression.range[1] + 1)
+        },
+        generated: {
+          start: position,
+          end: position + fragmentSql.length,
+          text: fragmentSql
+        },
+        offset: 0
+      });
+      continue;
+    }
+    const pgType = function_js.pipe(
+      mapExpressionToTsTypeString({ expression, parser, checker }),
+      (params) => getPgTypeFromTsType({ ...params, checker, options })
+    );
+    if (E__namespace.isLeft(pgType)) {
+      return E__namespace.left(checkSql_utils.InvalidQueryError.of(pgType.left, expression));
+    }
+    const pgTypeValue = pgType.right;
+    if (pgTypeValue === null) {
+      const placeholder2 = `$${++$idx}`;
+      $queryText += placeholder2;
+      sourcemaps.push({
+        original: {
+          text: sourceCode.text.slice(expression.range[0] - 2, expression.range[1] + 1),
+          start: expression.range[0] - quasi.range[0] - 2,
+          end: expression.range[1] - quasi.range[0] + 1
+        },
+        generated: {
+          text: placeholder2,
+          start: position,
+          end: position + placeholder2.length
+        },
+        offset: 0
+      });
+      continue;
+    }
+    if (pgTypeValue.kind === "literal") {
+      const placeholder2 = pgTypeValue.value;
+      $queryText += placeholder2;
+      sourcemaps.push({
+        original: {
+          start: expression.range[0] - quasi.range[0] - 2,
+          end: expression.range[1] - quasi.range[0] + 1,
+          text: sourceCode.text.slice(expression.range[0] - 2, expression.range[1] + 1)
+        },
+        generated: {
+          start: position,
+          end: position + placeholder2.length,
+          text: placeholder2
+        },
+        offset: 0
+      });
+      continue;
+    }
+    const escapePgValue = (text) => text.replace(/'/g, "''");
+    if (pgTypeValue.kind === "one-of" && $queryText.trimEnd().endsWith("=") && isLastQueryContextOneOf($queryText, ["SELECT", "ON", "WHERE", "WHEN", "HAVING", "RETURNING"])) {
+      const textFromEquals = $queryText.slice($queryText.lastIndexOf("="));
+      const placeholder2 = `IN (${pgTypeValue.types.map((t) => `'${escapePgValue(t)}'`).join(", ")})`;
+      const expressionText = sourceCode.text.slice(
+        expression.range[0] - 2,
+        expression.range[1] + 1
+      );
+      $queryText = $queryText.replace(/(=)\s*$/, "");
+      $queryText += placeholder2;
+      sourcemaps.push({
+        original: {
+          start: expression.range[0] - quasi.range[0] - 2 - textFromEquals.length,
+          end: expression.range[1] - quasi.range[0] + 2 - textFromEquals.length,
+          text: `${textFromEquals}${expressionText}`
+        },
+        generated: {
+          start: position - textFromEquals.length + 1,
+          end: position + placeholder2.length - textFromEquals.length,
+          text: placeholder2
+        },
+        offset: textFromEquals.length
+      });
+      continue;
+    }
+    const placeholder = `$${++$idx}::${pgTypeValue.cast}`;
+    $queryText += placeholder;
+    sourcemaps.push({
+      original: {
+        start: expression.range[0] - quasi.range[0] - 2,
+        end: expression.range[1] - quasi.range[0],
+        text: sourceCode.text.slice(expression.range[0] - 2, expression.range[1] + 1)
+      },
+      generated: {
+        start: position,
+        end: position + placeholder.length,
+        text: placeholder
+      },
+      offset: 0
+    });
+  }
+  return E__namespace.right({ text: $queryText, sourcemaps });
+}
+function mapExpressionToTsTypeString(params) {
+  const tsNode = params.parser.esTreeNodeToTSNodeMap.get(params.expression);
+  const tsType = params.checker.getTypeAtLocation(tsNode);
+  return {
+    node: tsNode,
+    type: tsType
+  };
+}
+const tsTypeToPgTypeMap = {
+  number: "int",
+  string: "text",
+  boolean: "boolean",
+  bigint: "bigint",
+  any: "text",
+  unknown: "text"
+};
+const tsFlagToPgTypeMap = {
+  [ts__default.TypeFlags.String]: "text",
+  [ts__default.TypeFlags.Number]: "int",
+  [ts__default.TypeFlags.Boolean]: "boolean",
+  [ts__default.TypeFlags.BigInt]: "bigint",
+  [ts__default.TypeFlags.NumberLiteral]: "int",
+  [ts__default.TypeFlags.StringLiteral]: "text",
+  [ts__default.TypeFlags.BooleanLiteral]: "boolean",
+  [ts__default.TypeFlags.BigIntLiteral]: "bigint"
+};
+function getPgTypeFromTsTypeUnion(params) {
+  const { types, checker, options } = params;
+  const nonNullTypes = types.filter((t) => (t.flags & ts__default.TypeFlags.Null) === 0);
+  if (nonNullTypes.length === 0) {
+    return E__namespace.right(null);
+  }
+  const hasSlonikToken = nonNullTypes.some((t) => {
+    const typeStr = checker.typeToString(t);
+    return isSlonikSqlTokenType(typeStr);
+  });
+  if (hasSlonikToken) {
+    return E__namespace.right(null);
+  }
+  const isStringLiterals = nonNullTypes.every((t) => t.flags & ts__default.TypeFlags.StringLiteral);
+  if (isStringLiterals) {
+    return E__namespace.right({
+      kind: "one-of",
+      types: nonNullTypes.map((t) => t.value),
+      cast: "text"
+    });
+  }
+  const results = nonNullTypes.map((t) => checkType({ checker, type: t, options }));
+  const strategies = [];
+  for (const result of results) {
+    if (E__namespace.isLeft(result)) {
+      return result;
+    }
+    if (result.right !== null) {
+      strategies.push(result.right);
+    }
+  }
+  if (strategies.length === 0) {
+    const typesStr = nonNullTypes.map((t) => checker.typeToString(t)).join(", ");
+    return E__namespace.left(`No PostgreSQL type could be inferred for the union members: ${typesStr}`);
+  }
+  const firstStrategy = strategies[0];
+  const mixedTypes = [firstStrategy.cast];
+  for (let i = 1; i < strategies.length; i++) {
+    const strategy = strategies[i];
+    if (strategy.cast !== firstStrategy.cast) {
+      mixedTypes.push(strategy.cast);
+    }
+  }
+  if (mixedTypes.length > 1) {
+    return E__namespace.left(
+      `Union types must result in the same PostgreSQL type (found ${mixedTypes.join(", ")})`
+    );
+  }
+  return E__namespace.right(firstStrategy);
+}
+function getPgTypeFromTsType(params) {
+  const { checker, node, type, options } = params;
+  const typeStr = checker.typeToString(type);
+  if (isSlonikSqlTokenType(typeStr)) {
+    return E__namespace.right(null);
+  }
+  if (node.kind === ts__default.SyntaxKind.ConditionalExpression) {
+    const trueType = checker.getTypeAtLocation(node.whenTrue);
+    const falseType = checker.getTypeAtLocation(node.whenFalse);
+    const trueTypeStr = checker.typeToString(trueType);
+    const falseTypeStr = checker.typeToString(falseType);
+    if (isSlonikSqlTokenType(trueTypeStr) || isSlonikSqlTokenType(falseTypeStr)) {
+      return E__namespace.right(null);
+    }
+    const whenTrue = checkType({
+      checker,
+      type: trueType,
+      options
+    });
+    const whenFalse = checkType({
+      checker,
+      type: falseType,
+      options
+    });
+    if (E__namespace.isLeft(whenTrue)) {
+      return whenTrue;
+    }
+    if (E__namespace.isLeft(whenFalse)) {
+      return whenFalse;
+    }
+    const trueStrategy = whenTrue.right;
+    const falseStrategy = whenFalse.right;
+    if (trueStrategy === null && falseStrategy === null) {
+      return E__namespace.right(null);
+    }
+    if (trueStrategy !== null && falseStrategy !== null && trueStrategy.cast !== falseStrategy.cast) {
+      return E__namespace.left(
+        `Conditional expression must have the same type (true = ${trueStrategy.cast}, false = ${falseStrategy.cast})`
+      );
+    }
+    const strategy = trueStrategy ?? falseStrategy;
+    if (strategy === null) {
+      return E__namespace.right(null);
+    }
+    return E__namespace.right({ kind: "cast", cast: strategy.cast });
+  }
+  return checkType({ checker, type, options });
+}
+function checkType(params) {
+  const { checker, type, options } = params;
+  if (type.flags & ts__default.TypeFlags.Null) {
+    return E__namespace.right(null);
+  }
+  const typeStr = checker.typeToString(type);
+  if (isSlonikSqlTokenType(typeStr)) {
+    return E__namespace.right(null);
+  }
+  const singularType = typeStr.replace(/\[\]$/, "");
+  const isArray = typeStr !== singularType;
+  const singularPgType = tsTypeToPgTypeMap[singularType];
+  if (singularPgType) {
+    return E__namespace.right({ kind: "cast", cast: isArray ? `${singularPgType}[]` : singularPgType });
+  }
+  const typesWithOverrides = { ...checkSql_utils.defaultTypeMapping, ...options.overrides?.types };
+  const override = Object.entries(typesWithOverrides).find(
+    ([, tsType]) => checkSql_utils.doesMatchPattern({
+      pattern: typeof tsType === "string" ? tsType : tsType.parameter,
+      text: singularType
+    })
+  );
+  if (override) {
+    const [pgType] = override;
+    return E__namespace.right({ kind: "cast", cast: isArray ? `${pgType}[]` : pgType });
+  }
+  const enumType = TSUtils.getEnumKind(type);
+  if (enumType) {
+    switch (enumType.kind) {
+      case "Const":
+      case "Numeric":
+        return E__namespace.right({ kind: "cast", cast: "int" });
+      case "String":
+        return E__namespace.right({ kind: "one-of", types: enumType.values, cast: "text" });
+      case "Heterogeneous":
+        return E__namespace.left("Heterogeneous enums are not supported");
+    }
+  }
+  if (checker.isArrayType(type)) {
+    const elementType = type.typeArguments?.[0];
+    if (elementType) {
+      return function_js.pipe(
+        checkType({ checker, type: elementType, options }),
+        E__namespace.map(
+          (pgType) => pgType === null ? null : { kind: "cast", cast: `${pgType.cast}[]` }
+        )
+      );
+    }
+  }
+  if (type.isStringLiteral()) {
+    return E__namespace.right({ kind: "literal", value: `'${type.value}'`, cast: "text" });
+  }
+  if (type.isNumberLiteral()) {
+    return E__namespace.right({ kind: "literal", value: `${type.value}`, cast: "int" });
+  }
+  if (type.isUnion()) {
+    return function_js.pipe(
+      getPgTypeFromTsTypeUnion({ types: type.types, checker, options }),
+      E__namespace.chain(
+        (pgType) => pgType === null ? E__namespace.left("Unsupported union type (only null)") : E__namespace.right(pgType)
+      )
+    );
+  }
+  if (type.flags in tsFlagToPgTypeMap) {
+    const pgType = tsFlagToPgTypeMap[type.flags];
+    return E__namespace.right({ kind: "cast", cast: isArray ? `${pgType}[]` : pgType });
+  }
+  return E__namespace.left(checkSql_utils.normalizeIndent`
+    The type "${typeStr}" has no corresponding PostgreSQL type.
+    Please add it manually using the "overrides.types" option:
+
+    \`\`\`ts
+    {
+      "connections": {
+        ...,
+        "overrides": {
+          "types": {
+            "PG TYPE (e.g. 'date')": "${typeStr}"
+          }
+        }
+      }
+    }
+    \`\`\`
+
+    Read docs - https://github.com/gajus/eslint-plugin-slonik#type-override-reference
+  `);
+}
+
+const distDir = node_url.fileURLToPath(new URL("../../dist", (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('shared/eslint-plugin-slonik.BxexVlk1.cjs', document.baseURI).href))));
+function defineWorker(params) {
+  return synckit.createSyncFn(path__default.join(distDir, `./workers/${params.name}.worker.mjs`), {
+    tsRunner: "tsx",
+    timeout: params.timeout
+  });
+}
+const workers = {
+  generateSync: defineWorker({ name: "check-sql", timeout: 1e3 * 60 * 1 })
+};
+
+const zStringOrRegex = z__default.union([z__default.string(), z__default.object({ regex: z__default.string() })]);
+const zBaseTarget = z__default.object({
+  /**
+   * Transform the end result of the type.
+   *
+   * For example:
+   *  - `"{type}[]"` will transform the type to an array
+   *  - `["colname", "x_colname"]` will replace `colname` with `x_colname` in the type.
+   *  - `["{type}[]", ["colname", x_colname"]]` will do both
+   */
+  transform: z__default.union([z__default.string(), z__default.array(z__default.union([z__default.string(), z__default.tuple([z__default.string(), z__default.string()])]))]).optional(),
+  /**
+   * Transform the (column) field key. Can be one of the following:
+   * - `"snake"` - `userId` → `user_id`
+   * - `"camel"` - `user_id` → `userId`
+   * - `"pascal"` - `user_id` → `UserId`
+   * - `"screaming snake"` - `user_id` → `USER_ID`
+   */
+  fieldTransform: z__default.enum(["snake", "pascal", "camel", "screaming snake"]).optional(),
+  /**
+   * Whether or not to skip type annotation.
+   */
+  skipTypeAnnotations: z__default.boolean().optional()
+});
+const zWrapperTarget = z__default.object({ wrapper: zStringOrRegex, maxDepth: z__default.number().optional() }).merge(zBaseTarget);
+const zTagTarget = z__default.object({ tag: zStringOrRegex }).merge(zBaseTarget);
+const zOverrideTypeResolver = z__default.union([
+  z__default.string(),
+  z__default.object({ parameter: zStringOrRegex, return: z__default.string() })
+]);
+const zBaseSchema = z__default.object({
+  targets: z__default.union([zWrapperTarget, zTagTarget]).array(),
+  /**
+   * Whether or not keep the connection alive. Change it only if you know what you're doing.
+   */
+  keepAlive: z__default.boolean().optional(),
+  /**
+   * Override defaults
+   */
+  overrides: z__default.object({
+    types: z__default.union([
+      z__default.record(z__default.enum(checkSql_utils.objectKeysNonEmpty(checkSql_utils.defaultTypeMapping)), zOverrideTypeResolver),
+      z__default.record(z__default.string(), zOverrideTypeResolver)
+    ]),
+    columns: z__default.record(z__default.string(), z__default.string())
+  }).partial().optional(),
+  /**
+   * Use `undefined` instead of `null` when the value is nullable.
+   */
+  nullAsUndefined: z__default.boolean().optional(),
+  /**
+   * Mark the property as optional when the value is nullable.
+   */
+  nullAsOptional: z__default.boolean().optional(),
+  /**
+   * Specifies whether to infer literals and their types.
+   * Can be a boolean or an array of specific types to infer.
+   *
+   * By default, it will infer all literals.
+   */
+  inferLiterals: z__default.union([z__default.boolean(), z__default.enum(["number", "string", "boolean"]).array()]).optional()
+});
+const zConnectionMigration = z__default.object({
+  /**
+   * The path where the migration files are located.
+   */
+  migrationsDir: z__default.string(),
+  /**
+   * THIS IS NOT THE PRODUCTION DATABASE.
+   *
+   * A connection url to the database.
+   * This is required since in order to run the migrations, a connection to postgres is required.
+   * Will be used only to create and drop the shadow database (see `databaseName`).
+   */
+  connectionUrl: z__default.string().optional(),
+  /**
+   * The name of the shadow database that will be created from the migration files.
+   */
+  databaseName: z__default.string().optional(),
+  /**
+   * Whether or not should refresh the shadow database when the migration files change.
+   */
+  watchMode: z__default.boolean().optional()
+});
+const zConnectionUrl = z__default.object({
+  /**
+   * The connection url to the database
+   */
+  databaseUrl: z__default.string()
+});
+const zRuleOptionConnection = z__default.union([
+  zBaseSchema.merge(zConnectionMigration),
+  zBaseSchema.merge(zConnectionUrl)
+]);
+const zConfig = z__default.object({
+  connections: z__default.union([z__default.array(zRuleOptionConnection), zRuleOptionConnection])
+});
+const UserConfigFile = z__default.object({
+  useConfigFile: z__default.boolean()
+});
+const Options = z__default.union([zConfig, UserConfigFile]);
+const RuleOptions = z__default.array(Options).min(1).max(1);
+const defaultInferLiteralOptions = ["string"];
+
+function getConfigFromFileWithContext(params) {
+  const options = params.context.options[0];
+  if (!isConfigFileRuleOptions(options)) {
+    return options;
+  }
+  return function_js.pipe(
+    getConfigFromFile(params.projectDir),
+    E__namespace.getOrElseW((message) => {
+      throw new Error(`eslint-plugin-slonik: ${message}`);
+    })
+  );
+}
+function getConfigFromFile(projectDir) {
+  try {
+    const configFilePath = path__default.join(projectDir, "slonik.config.ts");
+    const require$1 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('shared/eslint-plugin-slonik.BxexVlk1.cjs', document.baseURI).href)));
+    const rawConfig = require$1(`tsx/cjs/api`).require(configFilePath, configFilePath).default;
+    if (rawConfig === void 0) {
+      throw new checkSql_utils.InvalidConfigError(`slonik.config.ts must export a default value`);
+    }
+    const config = zConfig.safeParse(rawConfig);
+    if (!config.success) {
+      throw new checkSql_utils.InvalidConfigError(`slonik.config.ts is invalid: ${config.error.message}`);
+    }
+    return E__namespace.right(config.data);
+  } catch (error) {
+    return E__namespace.left(`${error}`);
+  }
+}
+function isConfigFileRuleOptions(options) {
+  return "useConfigFile" in options;
+}
+function defineConfig(config) {
+  return config;
+}
+
+const messages = {
+  typeInferenceFailed: "Type inference failed {{error}}",
+  error: "{{error}}",
+  invalidQuery: "Invalid Query: {{error}}",
+  missingTypeAnnotations: "Query is missing type annotation\n	Fix with: {{fix}}",
+  incorrectTypeAnnotations: `Query has incorrect type annotation.
+	Expected: {{expected}}
+	  Actual: {{actual}}`,
+  invalidTypeAnnotations: `Query has invalid type annotation (SafeQL does not support it. If you think it should, please open an issue)`
+};
+function check(params) {
+  const connections = Array.isArray(params.config.connections) ? params.config.connections : [params.config.connections];
+  for (const connection of connections) {
+    for (const target of connection.targets) {
+      checkConnection({ ...params, connection, target });
+    }
+  }
+}
+function isTagMemberValid(expr) {
+  if (checkSql_utils.isIdentifier(expr.tag)) {
+    return true;
+  }
+  if (checkSql_utils.isMemberExpression(expr.tag) && checkSql_utils.isIdentifier(expr.tag.property)) {
+    return true;
+  }
+  return false;
+}
+function checkConnection(params) {
+  if ("tag" in params.target) {
+    return checkConnectionByTagExpression({ ...params, target: params.target });
+  }
+  if ("wrapper" in params.target) {
+    return checkConnectionByWrapperExpression({ ...params, target: params.target });
+  }
+  return tsPattern.match(params.target).exhaustive();
+}
+const generateSyncE = function_js.flow(
+  workers.generateSync,
+  E__namespace.chain(J__namespace.parse),
+  E__namespace.chainW((parsed) => parsed),
+  E__namespace.mapLeft((error) => error)
+);
+let fatalError;
+function reportCheck(params) {
+  const { context, tag, connection, target, projectDir, typeParameter, baseNode } = params;
+  if (fatalError !== void 0) {
+    const hint = isInEditorEnv() ? "If you think this is a bug, please open an issue. If not, please try to fix the error and restart ESLint." : "If you think this is a bug, please open an issue.";
+    return checkSql_utils.reportBaseError({ context, error: fatalError, tag, hint });
+  }
+  const nullAsOptional = connection.nullAsOptional ?? false;
+  const nullAsUndefined = connection.nullAsUndefined ?? false;
+  return function_js.pipe(
+    E__namespace.Do,
+    E__namespace.bind("parser", () => {
+      return hasParserServicesWithTypeInformation(context.sourceCode.parserServices) ? E__namespace.right(context.sourceCode.parserServices) : E__namespace.left(new checkSql_utils.InvalidConfigError("Parser services are not available"));
+    }),
+    E__namespace.bind("checker", ({ parser }) => {
+      return !parser.program ? E__namespace.left(new checkSql_utils.InvalidConfigError("Type checker is not available")) : E__namespace.right(parser.program.getTypeChecker());
+    }),
+    E__namespace.bindW(
+      "query",
+      ({ parser, checker }) => mapTemplateLiteralToQueryText(
+        tag.quasi,
+        parser,
+        checker,
+        params.connection,
+        params.context.sourceCode
+      )
+    ),
+    E__namespace.bindW("result", ({ query }) => {
+      return generateSyncE({ query, connection, target, projectDir });
+    }),
+    E__namespace.fold(
+      (error) => {
+        return tsPattern.match(error).with({ _tag: "InvalidConfigError" }, (error2) => {
+          return checkSql_utils.reportInvalidConfig({ context, error: error2, tag });
+        }).with({ _tag: "DuplicateColumnsError" }, (error2) => {
+          return checkSql_utils.reportDuplicateColumns({ context, error: error2, tag });
+        }).with({ _tag: "PostgresError" }, (error2) => {
+          return checkSql_utils.reportPostgresError({ context, error: error2, tag });
+        }).with({ _tag: "InvalidQueryError" }, (error2) => {
+          return checkSql_utils.reportInvalidQueryError({ context, error: error2 });
+        }).with(
+          { _tag: "InvalidMigrationError" },
+          { _tag: "InvalidMigrationsPathError" },
+          { _tag: "DatabaseInitializationError" },
+          { _tag: "InternalError" },
+          (error2) => {
+            if (params.connection.keepAlive === true) {
+              fatalError = error2;
+            }
+            return checkSql_utils.reportBaseError({ context, error: error2, tag });
+          }
+        ).exhaustive();
+      },
+      ({ result, checker, parser }) => {
+        const shouldSkipTypeAnnotations = target.skipTypeAnnotations === true;
+        if (shouldSkipTypeAnnotations) {
+          return;
+        }
+        const isMissingTypeAnnotations = typeParameter === void 0;
+        if (isMissingTypeAnnotations) {
+          if (result.output === null) {
+            return;
+          }
+          return checkSql_utils.reportMissingTypeAnnotations({
+            tag,
+            context,
+            baseNode,
+            actual: checkSql_utils.getFinalResolvedTargetString({
+              target: result.output,
+              nullAsOptional: nullAsOptional ?? false,
+              nullAsUndefined: nullAsUndefined ?? false,
+              transform: target.transform,
+              inferLiterals: connection.inferLiterals ?? defaultInferLiteralOptions
+            })
+          });
+        }
+        const reservedTypes = memoize({
+          key: `reserved-types:${JSON.stringify(connection.overrides)}`,
+          value: () => {
+            const types = /* @__PURE__ */ new Set();
+            for (const value of Object.values(connection.overrides?.types ?? {})) {
+              types.add(typeof value === "string" ? value : value.return);
+            }
+            for (const columnType of Object.values(connection.overrides?.columns ?? {})) {
+              types.add(columnType);
+            }
+            return types;
+          }
+        });
+        const typeAnnotationState = getTypeAnnotationState({
+          generated: result.output,
+          typeParameter,
+          transform: target.transform,
+          checker,
+          parser,
+          reservedTypes,
+          nullAsOptional,
+          nullAsUndefined,
+          inferLiterals: connection.inferLiterals ?? defaultInferLiteralOptions
+        });
+        if (typeAnnotationState === "INVALID") {
+          return checkSql_utils.reportInvalidTypeAnnotations({
+            context,
+            typeParameter
+          });
+        }
+        if (!typeAnnotationState.isEqual) {
+          return checkSql_utils.reportIncorrectTypeAnnotations({
+            context,
+            typeParameter,
+            expected: checkSql_utils.fmap(
+              typeAnnotationState.expected,
+              (expected) => checkSql_utils.getResolvedTargetString({
+                target: expected,
+                nullAsOptional: false,
+                nullAsUndefined: false,
+                inferLiterals: params.connection.inferLiterals ?? defaultInferLiteralOptions
+              })
+            ),
+            actual: checkSql_utils.fmap(
+              result.output,
+              (output) => checkSql_utils.getFinalResolvedTargetString({
+                target: output,
+                nullAsOptional: connection.nullAsOptional ?? false,
+                nullAsUndefined: connection.nullAsUndefined ?? false,
+                transform: target.transform,
+                inferLiterals: connection.inferLiterals ?? defaultInferLiteralOptions
+              })
+            )
+          });
+        }
+      }
+    )
+  );
+}
+function hasParserServicesWithTypeInformation(parser) {
+  return parser !== void 0 && parser.program !== null;
+}
+function checkConnectionByTagExpression(params) {
+  const { context, tag, projectDir, connection, target } = params;
+  const tagAsText = context.sourceCode.getText(tag.tag).replace(/^this\./, "");
+  if (checkSql_utils.doesMatchPattern({ pattern: target.tag, text: tagAsText })) {
+    return reportCheck({
+      context,
+      tag,
+      connection,
+      target,
+      projectDir,
+      baseNode: tag.tag,
+      typeParameter: tag.typeArguments
+    });
+  }
+}
+function getValidParentUntilDepth(node, depth) {
+  if (node.type === "CallExpression" && node.callee.type === "MemberExpression") {
+    return node;
+  }
+  if (depth > 0 && node.parent) {
+    return getValidParentUntilDepth(node.parent, depth - 1);
+  }
+  return null;
+}
+function checkConnectionByWrapperExpression(params) {
+  const { context, tag, projectDir, connection, target } = params;
+  if (!isTagMemberValid(tag)) {
+    return;
+  }
+  const wrapperNode = getValidParentUntilDepth(tag.parent, target.maxDepth ?? 0);
+  if (wrapperNode === null) {
+    return;
+  }
+  const calleeAsText = context.sourceCode.getText(wrapperNode.callee).replace(/^this\./, "");
+  if (checkSql_utils.doesMatchPattern({ pattern: target.wrapper, text: calleeAsText })) {
+    return reportCheck({
+      context,
+      tag,
+      connection,
+      target,
+      projectDir,
+      baseNode: wrapperNode.callee,
+      typeParameter: wrapperNode.typeArguments
+    });
+  }
+}
+function getTypeAnnotationState({
+  generated,
+  typeParameter,
+  transform,
+  parser,
+  checker,
+  reservedTypes,
+  nullAsOptional,
+  nullAsUndefined,
+  inferLiterals
+}) {
+  if (typeParameter.params.length !== 1) {
+    return "INVALID";
+  }
+  const typeNode = typeParameter.params[0];
+  const expected = getResolvedTargetByTypeNode({
+    checker,
+    parser,
+    typeNode,
+    reservedTypes
+  });
+  return getResolvedTargetsEquality({
+    expected,
+    generated,
+    nullAsOptional,
+    nullAsUndefined,
+    inferLiterals,
+    transform
+  });
+}
+function getResolvedTargetsEquality(params) {
+  if (params.expected === null && params.generated === null) {
+    return {
+      isEqual: true,
+      expected: params.expected,
+      generated: params.generated
+    };
+  }
+  if (params.expected === null || params.generated === null) {
+    return {
+      isEqual: false,
+      expected: params.expected,
+      generated: params.generated
+    };
+  }
+  let expectedString = checkSql_utils.getResolvedTargetComparableString({
+    target: params.expected,
+    nullAsOptional: false,
+    nullAsUndefined: false,
+    inferLiterals: params.inferLiterals
+  });
+  let generatedString = checkSql_utils.getResolvedTargetComparableString({
+    target: params.generated,
+    nullAsOptional: params.nullAsOptional,
+    nullAsUndefined: params.nullAsUndefined,
+    inferLiterals: params.inferLiterals
+  });
+  if (expectedString === null || generatedString === null) {
+    return {
+      isEqual: false,
+      expected: params.expected,
+      generated: params.generated
+    };
+  }
+  expectedString = expectedString.replace(/'/g, '"');
+  generatedString = generatedString.replace(/'/g, '"');
+  expectedString = expectedString.split(", ").sort().join(", ");
+  generatedString = generatedString.split(", ").sort().join(", ");
+  if (params.transform !== void 0) {
+    generatedString = checkSql_utils.transformTypes(generatedString, params.transform);
+  }
+  return {
+    isEqual: expectedString === generatedString,
+    expected: params.expected,
+    generated: params.generated
+  };
+}
+const createRule = utils.ESLintUtils.RuleCreator(() => `https://github.com/gajus/eslint-plugin-slonik`);
+const checkSql = createRule({
+  name: "check-sql",
+  meta: {
+    fixable: "code",
+    docs: {
+      description: "Ensure that sql queries have type annotations"
+    },
+    messages,
+    type: "problem",
+    schema: z__default.toJSONSchema(RuleOptions, { target: "draft-4" })
+  },
+  defaultOptions: [],
+  create(context) {
+    if (!checkSql_utils.shouldLintFile(context)) {
+      return {};
+    }
+    const projectDir = memoize({
+      key: context.filename,
+      value: () => locateNearestPackageJsonDir(context.filename)
+    });
+    const config = memoize({
+      key: JSON.stringify({ key: "config", options: context.options, projectDir }),
+      value: () => getConfigFromFileWithContext({ context, projectDir })
+    });
+    return {
+      TaggedTemplateExpression(tag) {
+        check({ context, tag, config, projectDir });
+      }
+    };
+  }
+});
+
+const rules = {
+  "check-sql": checkSql
+};
+
+exports.defineConfig = defineConfig;
+exports.rules = rules;
+//# sourceMappingURL=eslint-plugin-slonik.BxexVlk1.cjs.map