@saleor/eslint-plugin-saleor-app/index.cjs

ESLint plugin for Saleor Apps

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name2 in all)
    __defProp(target, name2, { get: all[name2], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var src_exports = {};
__export(src_exports, {
  configs: () => configs,
  default: () => src_default,
  rules: () => rules
});
module.exports = __toCommonJS(src_exports);

// package.json
var name = "@saleor/eslint-plugin-saleor-app";
var version = "0.2.0";

// src/rules/logger.ts
var import_utils = require("@typescript-eslint/utils");
var tsutils = __toESM(require("tsutils"), 1);
var import_typescript = __toESM(require("typescript"), 1);
var loggerRules = import_utils.ESLintUtils.RuleCreator.withoutDocs({
  create(context, options) {
    const propertiesToCheck = new Set(options[0]);
    return {
      CallExpression(node) {
        if (node.callee.type === "MemberExpression" && node.callee.object.type === "Identifier" && propertiesToCheck.has(node.callee.object.name)) {
          const loggerData = node.arguments.find(
            (arg) => arg.type === "ObjectExpression"
          );
          if (loggerData) {
            const objectProperties = loggerData.properties;
            const parserServices = import_utils.ESLintUtils.getParserServices(context);
            const checker = parserServices.program.getTypeChecker();
            objectProperties.forEach((property) => {
              const tsNode = parserServices.esTreeNodeToTSNodeMap.get(property);
              const tsNodeType = checker.getTypeAtLocation(tsNode);
              if (property.type === "Property" && property.shorthand && property.value.type === "Identifier") {
                if (tsutils.isObjectType(tsNodeType) || tsutils.isGenericType(tsNodeType) || tsutils.isInterfaceType(tsNodeType) || tsutils.isSpreadElement(tsNode) || tsutils.isClassExpression(tsNode) || tsutils.isClassDeclaration(tsNode) || tsutils.isEmptyObjectType(tsNodeType)) {
                  context.report({
                    node: property,
                    messageId: "noShorthand"
                  });
                }
                if (tsutils.isArrayTypeNode(tsNode)) {
                  context.report({
                    node: property,
                    messageId: "noArray"
                  });
                }
                if (tsutils.isTypeFlagSet(tsNodeType, import_typescript.default.TypeFlags.Any) || tsutils.isTypeFlagSet(tsNodeType, import_typescript.default.TypeFlags.Unknown) || tsutils.isGenericType(tsNodeType)) {
                  context.report({
                    node: property,
                    messageId: "noUnknowns"
                  });
                }
              }
            });
          }
        }
      }
    };
  },
  meta: {
    type: "problem",
    docs: {
      description: "Invalid logs usage - object shorthand property"
    },
    messages: {
      noShorthand: "Potential PII leak: object shorthand property used with object value inside logger arguments. Pass only specific fields from the object to the logger.",
      noArray: "Potential PII leak: object shorthand property used with array value inside logger arguments. Please use `redactLogArray` method.",
      noUnknowns: "Potential PII leak: object shorthand property used with unknown value inside logger arguments. Please use only known values."
    },
    schema: [
      {
        type: "array",
        items: {
          type: "string",
          title: "Override logger names to check",
          default: ["logger"]
        }
      }
    ]
  },
  defaultOptions: [["logger"]]
});

// src/index.ts
var plugin = {
  meta: { name, version },
  rules: {
    "logger-leak": loggerRules
  },
  configs: {
    recommended: {
      plugins: ["@saleor/saleor-app"],
      rules: {
        "@saleor/saleor-app/logger-leak": "error"
      }
    },
    "flat/recommended": {
      name: "saleor-app/recommended",
      rules: {
        "@saleor/saleor-app/logger-leak": "error"
      }
    }
  }
};
var { rules, configs } = plugin;
var src_default = plugin;
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  configs,
  rules
});