ESLint Plugin Drizzle

Copyimport type { TSESLint } from '@typescript-eslint/utils';
import { name, version } from '../package.json';
import all from './configs/all';
import recommended from './configs/recommended';
import deleteRule from './enforce-delete-with-where';
import updateRule from './enforce-update-with-where';
import type { Options } from './utils/options';
 
export const rules = {
	'enforce-delete-with-where': deleteRule,
	'enforce-update-with-where': updateRule,
} satisfies Record<string, TSESLint.RuleModule<string, Options>>;
 
export const configs = { all, recommended };
 
export const meta = { name, version };

Copyexport default {
	env: {
		es2024: true,
	},
	parserOptions: {
		ecmaVersion: 'latest',
		sourceType: 'module',
	},
	plugins: ['drizzle'],
	rules: {
		'drizzle/enforce-delete-with-where': 'error',
		'drizzle/enforce-update-with-where': 'error',
	},
};

Copyconst deleteRule = createRule<Options, MessageIds>({
	defaultOptions: [{ drizzleObjectName: [] }],
	name: 'enforce-delete-with-where',
	meta: {
		type: 'problem',
		docs: {
			description: 'Enforce that `delete` method is used with `where` to avoid deleting all the rows in a table.',
		},
		fixable: 'code',
		messages: {
			enforceDeleteWithWhere:
				"Without `.where(...)` you will delete all the rows in a table. If you didn't want to do it, please use `{{ drizzleObjName }}.delete(...).where(...)` instead. Otherwise you can ignore this rule here",
		},
		schema: [{
			type: 'object',
			properties: {
				drizzleObjectName: {
					type: ['string', 'array'],
				},
			},
			additionalProperties: false,
		}],
	},

Copycreate(context, options) {
	return {
		MemberExpression: (node) => {
			if (node.property.type === 'Identifier') {
				if (node.property.name === 'delete' && lastNodeName !== 'where' && isDrizzleObj(node, options)) {
					context.report({
						node,
						messageId: 'enforceDeleteWithWhere',
						data: {
							drizzleObjName: resolveMemberExpressionPath(node),
						},
					});
				}
				lastNodeName = node.property.name;
			}
			return;
		},
	};
},

CopydefaultOptions: [{ drizzleObjectName: [] }],
name: 'enforce-update-with-where',
meta: {
	type: 'problem',
	docs: {
		description: 'Enforce that `update` method is used with `where` to avoid deleting all the rows in a table.',
	},
	fixable: 'code',
	messages: {
		enforceUpdateWithWhere:
			"Without `.where(...)` you will update all the rows in a table. If you didn't want to do it, please use `{{ drizzleObjName }}.update(...).set(...).where(...)` instead. Otherwise you can ignore this rule here",
	},
	schema: [{
		type: 'object',
		properties: {
			drizzleObjectName: {
				type: ['string', 'array'],
			},
		},
		additionalProperties: false,
	}],
},

Copycreate(context, options) {
	return {
		MemberExpression: (node) => {
			if (node.property.type === 'Identifier') {
				if (
					lastNodeName !== 'where'
					&& node.property.name === 'set'
					&& node.object.type === 'CallExpression'
					&& node.object.callee.type === 'MemberExpression'
					&& node.object.callee.property.type === 'Identifier'
					&& node.object.callee.property.name === 'update'
					&& isDrizzleObj(node.object.callee, options)
				) {
					context.report({
						node,
						messageId: 'enforceUpdateWithWhere',
						data: {
							drizzleObjName: resolveMemberExpressionPath(node.object.callee),
						},
					});
				}
				lastNodeName = node.property.name;
			}
			return;
		},
	};
},

Copyexport const resolveMemberExpressionPath = (node: TSESTree.MemberExpression) => {
	let objectExpression = node.object;
	let fullName = '';
 
	const addToFullName = (name: string) => {
		const prefix = fullName ? '.' : '';
		fullName = `${name}${prefix}${fullName}`;
	};
 
	while (objectExpression) {
		if (objectExpression.type === 'MemberExpression') {
			if (objectExpression.property.type === 'Identifier') {
				addToFullName(objectExpression.property.name);
			}
			objectExpression = objectExpression.object;
		} else if (objectExpression.type === 'CallExpression' && objectExpression.callee.type === 'Identifier') {
			addToFullName(`${objectExpression.callee.name}(...)`);
			break;
		} else if (objectExpression.type === 'CallExpression' && objectExpression.callee.type === 'MemberExpression') {
			if (objectExpression.callee.property.type === 'Identifier') {
				addToFullName(`${objectExpression.callee.property.name}(...)`);
			}
			objectExpression = objectExpression.callee.object;
		} else if (objectExpression.type === 'Identifier') {
			addToFullName(objectExpression.name);
			break;
		} else if (objectExpression.type === 'ThisExpression') {
			addToFullName('this');
			break;
		} else {
			break;
		}
	}
 
	return fullName;

Copyexport type Options = readonly [{
	drizzleObjectName: string[] | string;
}];
 
const isDrizzleObjName = (name: string, drizzleObjectName: string[] | string) => {
	if (typeof drizzleObjectName === 'string') {
		return name === drizzleObjectName;
	}
 
	if (Array.isArray(drizzleObjectName)) {
		if (drizzleObjectName.length === 0) {
			return true;
		}
 
		return drizzleObjectName.includes(name);
	}
 
	return false;
};

Copyexport const isDrizzleObj = (
	node: TSESTree.MemberExpression,
	options: Options,
) => {
	const drizzleObjectName = options[0].drizzleObjectName;
 
	if (node.object.type === 'Identifier') {
		return isDrizzleObjName(node.object.name, drizzleObjectName);
	} else if (node.object.type === 'MemberExpression' && node.object.property.type === 'Identifier') {
		return isDrizzleObjName(node.object.property.name, drizzleObjectName);
	} else if (node.object.type === 'CallExpression') {
		if (node.object.callee.type === 'Identifier') {
			return isDrizzleObjName(node.object.callee.name, drizzleObjectName);
		} else if (node.object.callee.type === 'MemberExpression' && node.object.callee.property.type === 'Identifier') {
			return isDrizzleObjName(node.object.callee.property.name, drizzleObjectName);
		}
	}
 
	return false;