@diia-inhouse/oxc-config 1.9.2

package/dist/oxlint/plugins/codeConventions.mjs

@@ -0,0 +1,278 @@
+function hasInlineObjectReturnType(node) {
+    return node.returnType && node.returnType.type === 'TSTypeAnnotation' && node.returnType.typeAnnotation.type === 'TSTypeLiteral'
+}
+
+function normalize(str) {
+    return str.replace(/[_-]/g, '').toLowerCase()
+}
+
+function isEnumLikeObject(node) {
+    if (node.type !== 'ObjectExpression' || node.properties.length === 0) {
+        return false
+    }
+
+    return node.properties.every((prop) => {
+        if (prop.type !== 'Property' || prop.computed) {
+            return false
+        }
+
+        const key = prop.key.type === 'Identifier' ? prop.key.name : prop.key.type === 'Literal' ? String(prop.key.value) : null
+
+        if (!key) {
+            return false
+        }
+
+        if (prop.value.type !== 'Literal' || typeof prop.value.value !== 'string') {
+            return false
+        }
+
+        return normalize(key) === normalize(prop.value.value)
+    })
+}
+
+function isTopLevel(node) {
+    const parent = node.parent
+
+    return parent.type === 'Program' || (parent.type === 'ExportNamedDeclaration' && parent.parent.type === 'Program')
+}
+
+function getEnumObject(init) {
+    if (!init) {
+        return null
+    }
+
+    let expr = init
+
+    if (expr.type === 'TSSatisfiesExpression') {
+        expr = expr.expression
+    }
+
+    if (expr.type === 'TSAsExpression') {
+        expr = expr.expression
+    }
+
+    return isEnumLikeObject(expr) ? expr : null
+}
+
+function capitalizeFirst(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1)
+}
+
+function isValidPlural(rawSingular, rawPlural) {
+    const singular = capitalizeFirst(rawSingular)
+    const plural = capitalizeFirst(rawPlural)
+
+    if (plural === singular + 's') {
+        return true
+    }
+
+    if (plural === singular + 'es' && /(?:s|x|z|sh|ch)$/.test(singular)) {
+        return true
+    }
+
+    if (singular.endsWith('y') && plural === singular.slice(0, -1) + 'ies') {
+        return true
+    }
+
+    return false
+}
+
+export default {
+    meta: { name: '@diia-inhouse/oxlint-plugin-code' },
+    rules: {
+        'no-inline-object-return-type': {
+            meta: {
+                type: 'problem',
+                messages: {
+                    forbidden:
+                        'Do not use inline object return types. Declare a named interface or type alias (e.g. `*Response`, `*Result`) instead.',
+                },
+            },
+            create(context) {
+                function check(node) {
+                    if (hasInlineObjectReturnType(node)) {
+                        context.report({ node: node.returnType, messageId: 'forbidden' })
+                    }
+                }
+
+                return {
+                    FunctionDeclaration(node) {
+                        check(node)
+                    },
+                    FunctionExpression(node) {
+                        if (node.parent && node.parent.type === 'MethodDefinition') {
+                            return
+                        }
+
+                        check(node)
+                    },
+                    ArrowFunctionExpression(node) {
+                        check(node)
+                    },
+                    MethodDefinition(node) {
+                        if (node.value) {
+                            check(node.value)
+                        }
+                    },
+                }
+            },
+        },
+
+        'no-promise-settimeout': {
+            meta: {
+                type: 'problem',
+                messages: {
+                    forbidden: 'Do not wrap setTimeout in a Promise. Use `import { setTimeout } from "node:timers/promises"` instead.',
+                },
+            },
+            create(context) {
+                return {
+                    NewExpression(node) {
+                        if (node.callee.type !== 'Identifier' || node.callee.name !== 'Promise') {
+                            return
+                        }
+
+                        const callback = node.arguments[0]
+
+                        if (!callback || (callback.type !== 'ArrowFunctionExpression' && callback.type !== 'FunctionExpression')) {
+                            return
+                        }
+
+                        const body = callback.body
+
+                        const exprToCheck =
+                            body.type === 'CallExpression'
+                                ? body
+                                : body.type === 'BlockStatement' && body.body.length === 1 && body.body[0].type === 'ExpressionStatement'
+                                  ? body.body[0].expression
+                                  : null
+
+                        if (
+                            exprToCheck &&
+                            exprToCheck.type === 'CallExpression' &&
+                            exprToCheck.callee.type === 'Identifier' &&
+                            exprToCheck.callee.name === 'setTimeout'
+                        ) {
+                            context.report({ node, messageId: 'forbidden' })
+                        }
+                    },
+                }
+            },
+        },
+
+        'const-enum-naming': {
+            meta: {
+                type: 'suggestion',
+                messages: {
+                    notPascalCase: "Enum-like const object '{{name}}' should use PascalCase naming.",
+                    notPlural: "Enum-like const object '{{name}}' should have a plural name (e.g., '{{name}}s').",
+                },
+            },
+            create(context) {
+                return {
+                    VariableDeclaration(node) {
+                        if (node.kind !== 'const' || !isTopLevel(node)) {
+                            return
+                        }
+
+                        for (const declarator of node.declarations) {
+                            if (!declarator.id || declarator.id.type !== 'Identifier') {
+                                continue
+                            }
+
+                            if (!getEnumObject(declarator.init)) {
+                                continue
+                            }
+
+                            const name = declarator.id.name
+
+                            if (!/^[A-Z]/.test(name)) {
+                                context.report({ node: declarator.id, messageId: 'notPascalCase', data: { name } })
+                            }
+
+                            if (!name.endsWith('s')) {
+                                context.report({ node: declarator.id, messageId: 'notPlural', data: { name } })
+                            }
+                        }
+                    },
+                }
+            },
+        },
+
+        'const-enum-type-name': {
+            meta: {
+                type: 'suggestion',
+                messages: {
+                    notSingular: "Type '{{typeName}}' derived from '{{objectName}}' should be the singular form of the object name.",
+                },
+            },
+            create(context) {
+                return {
+                    TSTypeAliasDeclaration(node) {
+                        const typeAnnotation = node.typeAnnotation
+
+                        if (typeAnnotation.type !== 'TSIndexedAccessType') {
+                            return
+                        }
+
+                        const objectType = typeAnnotation.objectType
+
+                        if (objectType.type !== 'TSTypeQuery' || !objectType.exprName || objectType.exprName.type !== 'Identifier') {
+                            return
+                        }
+
+                        const objectName = objectType.exprName.name
+                        const indexType = typeAnnotation.indexType
+
+                        if (indexType.type !== 'TSTypeOperator' || indexType.operator !== 'keyof') {
+                            return
+                        }
+
+                        if (
+                            !indexType.typeAnnotation ||
+                            indexType.typeAnnotation.type !== 'TSTypeQuery' ||
+                            !indexType.typeAnnotation.exprName ||
+                            indexType.typeAnnotation.exprName.type !== 'Identifier'
+                        ) {
+                            return
+                        }
+
+                        if (indexType.typeAnnotation.exprName.name !== objectName) {
+                            return
+                        }
+
+                        const typeName = node.id.name
+
+                        if (!isValidPlural(typeName, objectName)) {
+                            context.report({ node: node.id, messageId: 'notSingular', data: { typeName, objectName } })
+                        }
+                    },
+                }
+            },
+        },
+
+        'prefer-as-const-object': {
+            meta: {
+                type: 'suggestion',
+                messages: {
+                    missingAsConst: 'Enum-like objects where values match keys should use `as const` to preserve literal types.',
+                },
+            },
+            create(context) {
+                return {
+                    VariableDeclaration(node) {
+                        if (node.kind !== 'const' || !isTopLevel(node)) {
+                            return
+                        }
+
+                        for (const declarator of node.declarations) {
+                            if (declarator.init && isEnumLikeObject(declarator.init)) {
+                                context.report({ node: declarator.init, messageId: 'missingAsConst' })
+                            }
+                        }
+                    },
+                }
+            },
+        },
+    },
+}

package/dist/oxlint/plugins/mongooseSchema.mjs

@@ -0,0 +1,183 @@
+function isSchemaConstructor(callee) {
+    return (
+        (callee.type === 'Identifier' && callee.name === 'Schema') ||
+        (callee.type === 'MemberExpression' &&
+            callee.object.type === 'Identifier' &&
+            callee.object.name === 'mongoose' &&
+            callee.property.type === 'Identifier' &&
+            callee.property.name === 'Schema')
+    )
+}
+
+function getOptionValue(optionsNode, key) {
+    if (!optionsNode || optionsNode.type !== 'ObjectExpression') {
+        return undefined
+    }
+
+    const prop = optionsNode.properties.find((p) => p.type === 'Property' && p.key.type === 'Identifier' && p.key.name === key)
+
+    if (!prop) {
+        return undefined
+    }
+
+    return prop.value.type === 'Literal' ? prop.value.value : undefined
+}
+
+function isModelFile(filename) {
+    return filename.includes('/models/')
+}
+
+export default {
+    meta: { name: '@diia-inhouse/oxlint-plugin-mongoose' },
+    rules: {
+        'schema-timestamps': {
+            meta: {
+                type: 'problem',
+                messages: {
+                    missing: 'Mongoose schema is missing { timestamps: true } in options.',
+                },
+            },
+            create(context) {
+                if (!isModelFile(context.filename)) {
+                    return {}
+                }
+
+                const subSchemaVars = new Set()
+
+                return {
+                    'VariableDeclarator[init.type="NewExpression"]'(node) {
+                        if (!isSchemaConstructor(node.init.callee)) {
+                            return
+                        }
+
+                        const options = node.init.arguments[1]
+
+                        if (getOptionValue(options, '_id') === false) {
+                            subSchemaVars.add(node.id.name)
+                        }
+                    },
+                    'ExportDefaultDeclaration, ExportNamedDeclaration'() {
+                        // Reset tracking per export boundary — not needed
+                    },
+                    'Program:exit'(programNode) {
+                        for (const stmt of programNode.body) {
+                            if (stmt.type !== 'VariableDeclaration') {
+                                continue
+                            }
+
+                            for (const decl of stmt.declarations) {
+                                if (!decl.init || decl.init.type !== 'NewExpression' || !isSchemaConstructor(decl.init.callee)) {
+                                    continue
+                                }
+
+                                if (subSchemaVars.has(decl.id.name)) {
+                                    continue
+                                }
+
+                                const options = decl.init.arguments[1]
+
+                                if (getOptionValue(options, 'timestamps') !== true) {
+                                    context.report({ node: decl, messageId: 'missing' })
+                                }
+                            }
+                        }
+                    },
+                }
+            },
+        },
+
+        'sub-schema-id-false': {
+            meta: {
+                type: 'problem',
+                messages: {
+                    missing: 'Sub-schema is missing { _id: false } in options. Embedded documents should not generate _id.',
+                },
+            },
+            create(context) {
+                if (!isModelFile(context.filename)) {
+                    return {}
+                }
+
+                const schemaVars = new Map()
+
+                return {
+                    VariableDeclarator(node) {
+                        if (!node.init || node.init.type !== 'NewExpression' || !isSchemaConstructor(node.init.callee)) {
+                            return
+                        }
+
+                        schemaVars.set(node.id.name, {
+                            node: node.init,
+                            hasIdFalse: getOptionValue(node.init.arguments[1], '_id') === false,
+                            hasTimestamps: getOptionValue(node.init.arguments[1], 'timestamps') === true,
+                            usedAsSubSchema: false,
+                        })
+                    },
+                    Property(node) {
+                        if (node.key.type !== 'Identifier' || node.key.name !== 'type' || node.value.type !== 'ArrayExpression') {
+                            return
+                        }
+
+                        for (const el of node.value.elements) {
+                            if (el && el.type === 'Identifier' && schemaVars.has(el.name)) {
+                                schemaVars.get(el.name).usedAsSubSchema = true
+                            }
+                        }
+                    },
+                    'Program:exit'() {
+                        for (const [, info] of schemaVars) {
+                            if (info.usedAsSubSchema && !info.hasIdFalse) {
+                                context.report({ node: info.node, messageId: 'missing' })
+                            }
+                        }
+                    },
+                }
+            },
+        },
+
+        'status-requires-history': {
+            meta: {
+                type: 'problem',
+                messages: {
+                    missing:
+                        'Schema has "status" field but no "statusHistory". Every model with status MUST have statusHistory — missing it is a data corruption bug.',
+                },
+            },
+            create(context) {
+                if (!isModelFile(context.filename)) {
+                    return {}
+                }
+
+                return {
+                    NewExpression(node) {
+                        if (!isSchemaConstructor(node.callee)) {
+                            return
+                        }
+
+                        const options = node.arguments[1]
+
+                        if (getOptionValue(options, '_id') === false) {
+                            return
+                        }
+
+                        const fields = node.arguments[0]
+
+                        if (!fields || fields.type !== 'ObjectExpression') {
+                            return
+                        }
+
+                        const fieldNames = new Set(
+                            fields.properties.filter((p) => p.type === 'Property' && p.key.type === 'Identifier').map((p) => p.key.name),
+                        )
+
+                        const hasHistory = [...fieldNames].some((name) => name.toLowerCase().includes('statushistor'))
+
+                        if (fieldNames.has('status') && !hasHistory) {
+                            context.report({ node, messageId: 'missing' })
+                        }
+                    },
+                }
+            },
+        },
+    },
+}

package/dist/oxlint/plugins/noHardcodedCyrillic.mjs

@@ -0,0 +1,43 @@
+const CYRILLIC_PATTERN = /[\u0400-\u04FF\u0500-\u052F]/
+
+const EXCLUDED_PATHS = ['/locales/', '.spec.ts', '.test.ts', '/tests/']
+
+function isExcludedFile(filename) {
+    return EXCLUDED_PATHS.some((path) => filename.includes(path))
+}
+
+function checkStringNode(context, node) {
+    if (isExcludedFile(context.filename)) {
+        return
+    }
+
+    const value = node.type === 'TemplateLiteral' ? node.quasis.map((q) => q.value.raw).join('') : node.value
+
+    if (typeof value === 'string' && CYRILLIC_PATTERN.test(value)) {
+        context.report({ node, messageId: 'forbidden', data: { text: value.length > 50 ? value.slice(0, 50) + '...' : value } })
+    }
+}
+
+export default {
+    meta: { name: '@diia-inhouse/oxlint-plugin-locale' },
+    rules: {
+        'no-hardcoded-cyrillic': {
+            meta: {
+                type: 'problem',
+                messages: {
+                    forbidden: 'Hardcoded Cyrillic string "{{ text }}" found. Move user-facing text to locale files and use i18n service.',
+                },
+            },
+            create(context) {
+                return {
+                    Literal(node) {
+                        checkStringNode(context, node)
+                    },
+                    TemplateLiteral(node) {
+                        checkStringNode(context, node)
+                    },
+                }
+            },
+        },
+    },
+}

package/dist/oxlint/plugins/packageCheck.mjs

@@ -0,0 +1,84 @@
+import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+
+let pkg = null
+let loaded = false
+
+function loadPackageJson() {
+    if (loaded) {
+        return pkg
+    }
+
+    loaded = true
+
+    try {
+        pkg = JSON.parse(readFileSync(resolve('package.json'), 'utf8'))
+    } catch {
+        // package.json not found or not parseable
+    }
+
+    return pkg
+}
+
+const VERSION_RANGE_PATTERN = /^[\^~]/
+
+const DEP_FIELDS = ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies']
+
+export default {
+    meta: { name: '@diia-inhouse/oxlint-plugin-package' },
+    rules: {
+        'no-service-in-package-name': {
+            meta: {
+                type: 'problem',
+                messages: {
+                    forbidden: 'package.json "name" field must not contain the word "service" (found: "{{ name }}")',
+                },
+            },
+            create(context) {
+                return {
+                    Program(node) {
+                        const data = loadPackageJson()
+
+                        if (data?.name?.includes('service')) {
+                            context.report({ node, messageId: 'forbidden', data: { name: data.name } })
+                        }
+                    },
+                }
+            },
+        },
+
+        'pinned-dependencies': {
+            meta: {
+                type: 'problem',
+                messages: {
+                    unpinned: 'Dependency "{{ name }}" has unpinned version "{{ version }}". Pin to an exact version (remove ^ or ~).',
+                },
+            },
+            create(context) {
+                return {
+                    Program(node) {
+                        const data = loadPackageJson()
+
+                        if (!data) {
+                            return
+                        }
+
+                        for (const field of DEP_FIELDS) {
+                            const deps = data[field]
+
+                            if (!deps) {
+                                continue
+                            }
+
+                            for (const [name, version] of Object.entries(deps)) {
+                                if (typeof version === 'string' && VERSION_RANGE_PATTERN.test(version)) {
+                                    context.report({ node, messageId: 'unpinned', data: { name, version } })
+                                }
+                            }
+                        }
+                    },
+                }
+            },
+        },
+    },
+}