eslint-plugin-slonik 1.7.0 → 1.8.0

package/dist/index.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-const checkSql_utils = require('./shared/eslint-plugin-slonik.rlOTrCdf.cjs');
+const checkSql_utils = require('./shared/eslint-plugin-slonik.kniz1QWh.cjs');
 const utils = require('@typescript-eslint/utils');
 const tsPattern = require('ts-pattern');
 const E = require('fp-ts/lib/Either.js');
@@ -8,9 +8,9 @@ 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 ts = require('typescript');
 const synckit = require('synckit');
 const node_url = require('node:url');
 const z = require('zod');
@@ -35,226 +35,16 @@ function _interopNamespaceCompat(e) {
 
 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 ts__default = /*#__PURE__*/_interopDefaultCompat(ts);
 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) {
-  if (!params.typeNode) {
-    console.error("[slonik/check-sql] DEBUG: typeNode is undefined in getResolvedTargetByTypeNode");
-    throw new Error("typeNode is undefined");
-  }
-  const tsNode = params.parser.esTreeNodeToTSNodeMap.get(params.typeNode);
-  if (!tsNode) {
-    console.error("[slonik/check-sql] DEBUG: Could not map ESTree node to TS node. typeNode.type:", params.typeNode.type);
-    throw new Error(`Could not map ESTree node (type: ${params.typeNode.type}) to TS node`);
-  }
-  const typeText = tsNode.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 isIdentifier(node) {
+  return node?.type === utils.TSESTree.AST_NODE_TYPES.Identifier;
 }
-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 isMemberExpression(node) {
+  return node?.type === utils.TSESTree.AST_NODE_TYPES.MemberExpression;
 }
 
 function isInEditorEnv() {
@@ -1189,7 +979,6 @@ const zConfig = z__default.object({
   connections: z__default.union([z__default.array(zRuleOptionConnection), zRuleOptionConnection])
 });
 const RuleOptions = z__default.array(zConfig).min(1).max(1);
-const defaultInferLiteralOptions = ["string"];
 
 function getConfigFromFileWithContext(params) {
   return params.context.options[0];
@@ -1198,12 +987,7 @@ function getConfigFromFileWithContext(params) {
 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)`
+  invalidQuery: "Invalid Query: {{error}}"
 };
 function check(params) {
   const connections = Array.isArray(params.config.connections) ? params.config.connections : [params.config.connections];
@@ -1214,10 +998,10 @@ function check(params) {
   }
 }
 function isTagMemberValid(expr) {
-  if (checkSql_utils.isIdentifier(expr.tag)) {
+  if (isIdentifier(expr.tag)) {
     return true;
   }
-  if (checkSql_utils.isMemberExpression(expr.tag) && checkSql_utils.isIdentifier(expr.tag.property)) {
+  if (isMemberExpression(expr.tag) && isIdentifier(expr.tag.property)) {
     return true;
   }
   return false;
@@ -1239,13 +1023,11 @@ const generateSyncE = function_js.flow(
 );
 let fatalError;
 function reportCheck(params) {
-  const { context, tag, connection, target, projectDir, typeParameter, baseNode } = params;
+  const { context, tag, connection, target, projectDir } = 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", () => {
@@ -1309,83 +1091,7 @@ If you believe this query should be supported, please open an issue at https://g
           return;
         }).exhaustive();
       },
-      ({ result, checker, parser }) => {
-        if (result === null) {
-          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
-              })
-            )
-          });
-        }
+      () => {
       }
     )
   );
@@ -1439,98 +1145,13 @@ function checkConnectionByWrapperExpression(params) {
     });
   }
 }
-function getTypeAnnotationState({
-  generated,
-  typeParameter,
-  transform,
-  parser,
-  checker,
-  reservedTypes,
-  nullAsOptional,
-  nullAsUndefined,
-  inferLiterals
-}) {
-  if (typeParameter.params.length !== 1) {
-    return "INVALID";
-  }
-  const typeNode = typeParameter.params[0];
-  let expected;
-  try {
-    expected = getResolvedTargetByTypeNode({
-      checker,
-      parser,
-      typeNode,
-      reservedTypes
-    });
-  } catch (error) {
-    console.error("[slonik/check-sql] DEBUG: Error in getResolvedTargetByTypeNode:", error);
-    console.error("[slonik/check-sql] DEBUG: typeNode:", typeNode);
-    console.error("[slonik/check-sql] DEBUG: typeNode.type:", typeNode?.type);
-    throw error;
-  }
-  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"
+      description: "Validate SQL queries against the database schema"
     },
     messages,
     type: "problem",