eslint-plugin-slonik 1.6.1 → 1.8.0

package/README.md

@@ -42,24 +42,23 @@ export default [
     overrides: {
       types: {
         // Map PostgreSQL types to Slonik token types
-        date: "DateSqlToken",
-        timestamp: "TimestampSqlToken",
-        interval: "IntervalSqlToken",
-        json: "JsonSqlToken",
-        jsonb: "JsonBinarySqlToken",
-        uuid: "UuidSqlToken",
-        "int4[]": 'ArraySqlToken<"int4">',
-        "text[]": 'ArraySqlToken<"text">',
-        "uuid[]": 'ArraySqlToken<"uuid">',
-        "numeric[]": 'ArraySqlToken<"numeric">',
-        "real[]": "VectorSqlToken",
+        date: 'DateSqlToken',
+        timestamp: 'TimestampSqlToken',
+        interval: 'IntervalSqlToken',
+        json: 'JsonSqlToken',
+        jsonb: 'JsonBinarySqlToken',
+        uuid: 'UuidSqlToken',
+        'int4[]': 'ArraySqlToken<"int4">',
+        'text[]': 'ArraySqlToken<"text">',
+        'uuid[]': 'ArraySqlToken<"uuid">',
+        'numeric[]': 'ArraySqlToken<"numeric">',
+        'real[]': 'VectorSqlToken',
       },
     },
     targets: [
       {
         // Match Slonik's typed query methods
-        tag: "sql.+(type\\(*\\)|typeAlias\\(*\\)|unsafe)",
-        skipTypeAnnotations: true,
+        tag: 'sql.+(type\\(*\\)|typeAlias\\(*\\)|unsafe)',
       },
     ],
   }),
@@ -131,14 +130,14 @@ When using Slonik, you'll want to map PostgreSQL types to Slonik's token types:
 overrides: {
   types: {
     // Date/Time types
-    date: "DateSqlToken",
-    timestamp: "TimestampSqlToken",
+    date: 'DateSqlToken',
+    timestamp: 'TimestampSqlToken',
     timestamptz: "TimestampSqlToken",
-    interval: "IntervalSqlToken",
+    interval: 'IntervalSqlToken',
 
     // JSON types
-    json: "JsonSqlToken",
-    jsonb: "JsonBinarySqlToken",
+    json: 'JsonSqlToken',
+    jsonb: 'JsonBinarySqlToken',
 
     // UUID
     uuid: "UuidSqlToken",
@@ -167,7 +166,6 @@ targets: [
   {
     // Matches: sql.type(...)``, sql.typeAlias(...)``, sql.unsafe``
     tag: "sql.+(type\\(*\\)|typeAlias\\(*\\)|unsafe)",
-    skipTypeAnnotations: true,
   },
 ]
 ```
@@ -209,19 +207,18 @@ export default tseslint.config(
     databaseUrl: process.env.DATABASE_URL,
     overrides: {
       types: {
-        date: "DateSqlToken",
-        timestamp: "TimestampSqlToken",
-        json: "JsonSqlToken",
-        jsonb: "JsonBinarySqlToken",
-        uuid: "UuidSqlToken",
-        "int4[]": 'ArraySqlToken<"int4">',
-        "text[]": 'ArraySqlToken<"text">',
+        date: 'DateSqlToken',
+        timestamp: 'TimestampSqlToken',
+        json: 'JsonSqlToken',
+        jsonb: 'JsonBinarySqlToken',
+        uuid: 'UuidSqlToken',
+        'int4[]': 'ArraySqlToken<"int4">',
+        'text[]': 'ArraySqlToken<"text">',
       },
     },
     targets: [
       {
-        tag: "sql.+(type\\(*\\)|typeAlias\\(*\\)|unsafe)",
-        skipTypeAnnotations: true,
+        tag: 'sql.+(type\\(*\\)|typeAlias\\(*\\)|unsafe)',
       },
     ],
   })
@@ -273,6 +270,18 @@ This plugin is specifically designed for Slonik and includes:
 4. **Identifier support** — Converts `sql.identifier()` to quoted identifiers
 5. **Graceful degradation** — Skips validation for runtime-dependent constructs instead of erroring
 
+## How It Works
+
+ESLint rules must be synchronous, but SQL validation requires async operations like database connections. This plugin solves this using [`synckit`](https://github.com/un-ts/synckit), which enables synchronous calls to async worker threads.
+
+The architecture:
+
+1. **Worker Thread** — Runs all async operations (database connections, migrations, type generation) in a separate thread
+2. **Synchronous Bridge** — Uses `synckit` to block the main thread until the worker completes, making async operations appear synchronous to ESLint
+3. **Connection Pooling** — Reuses database connections across lint runs for performance
+
+Under the hood, `synckit` uses Node.js Worker Threads with `Atomics.wait()` to block the main thread until the worker signals completion via `Atomics.notify()`.
+
 ## Development
 
 ### Prerequisites

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 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 isIdentifier(node) {
+  return node?.type === utils.TSESTree.AST_NODE_TYPES.Identifier;
 }
-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() {
@@ -1108,11 +898,7 @@ const zBaseTarget = z__default.object({
    * - `"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()
+  fieldTransform: z__default.enum(["snake", "pascal", "camel", "screaming snake"]).optional()
 });
 const zWrapperTarget = z__default.object({ wrapper: zStringOrRegex, maxDepth: z__default.number().optional() }).merge(zBaseTarget);
 const zTagTarget = z__default.object({ tag: zStringOrRegex }).merge(zBaseTarget);
@@ -1193,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];
@@ -1202,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];
@@ -1218,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;
@@ -1243,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,89 +1087,11 @@ function reportCheck(params) {
 If you believe this query should be supported, please open an issue at https://github.com/gajus/eslint-plugin-slonik/issues`
           );
           return;
+        }).with({ _tag: "ConnectionFailedError" }, () => {
+          return;
         }).exhaustive();
       },
-      ({ result, checker, parser }) => {
-        if (result === null) {
-          return;
-        }
-        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
-              })
-            )
-          });
-        }
+      () => {
       }
     )
   );
@@ -1445,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",