@diia-inhouse/oxc-config 1.9.2

package/dist/oxlint/plugins/temporalConventions.mjs

@@ -0,0 +1,169 @@
+function isTestFile(filename) {
+    return filename.includes('/tests/') || filename.includes('/test/')
+}
+
+function isWorkflowFile(filename) {
+    return !isTestFile(filename) && filename.includes('/worker/workflows/') && !filename.includes('.types.')
+}
+
+function isActivityFile(filename) {
+    return !isTestFile(filename) && filename.includes('/worker/activities/')
+}
+
+const FORBIDDEN_NODE_MODULES = new Set([
+    'node:path',
+    'path',
+    'node:fs',
+    'fs',
+    'node:fs/promises',
+    'fs/promises',
+    'node:crypto',
+    'crypto',
+    'node:child_process',
+    'child_process',
+    'node:os',
+    'os',
+    'node:net',
+    'net',
+    'node:dns',
+    'dns',
+    'node:http',
+    'http',
+    'node:https',
+    'https',
+])
+
+export default {
+    meta: { name: '@diia-inhouse/oxlint-plugin-temporal' },
+    rules: {
+        'workflow-single-param': {
+            meta: {
+                type: 'problem',
+                messages: {
+                    tooMany:
+                        'Workflow function "{{ name }}" has {{ count }} parameters. Workflows must accept a single object parameter for serialization compatibility.',
+                },
+            },
+            create(context) {
+                if (!isWorkflowFile(context.filename)) {
+                    return {}
+                }
+
+                function checkFunction(node, name) {
+                    if (node.params.length > 1) {
+                        context.report({
+                            node,
+                            messageId: 'tooMany',
+                            data: { name: name || '<anonymous>', count: String(node.params.length) },
+                        })
+                    }
+                }
+
+                return {
+                    'ExportNamedDeclaration > FunctionDeclaration'(node) {
+                        checkFunction(node, node.id?.name)
+                    },
+                    'ExportNamedDeclaration > VariableDeclaration > VariableDeclarator'(node) {
+                        if (node.init && (node.init.type === 'ArrowFunctionExpression' || node.init.type === 'FunctionExpression')) {
+                            checkFunction(node.init, node.id?.name)
+                        }
+                    },
+                }
+            },
+        },
+
+        'async-activity': {
+            meta: {
+                type: 'problem',
+                messages: {
+                    notAsync: 'Activity method "{{ name }}" must be async. All Temporal activities must be async functions.',
+                },
+            },
+            create(context) {
+                if (!isActivityFile(context.filename)) {
+                    return {}
+                }
+
+                return {
+                    MethodDefinition(node) {
+                        if (node.kind === 'constructor' || node.key.type !== 'Identifier' || node.accessibility === 'private') {
+                            return
+                        }
+
+                        const fn = node.value
+
+                        if (fn && !fn.async) {
+                            context.report({
+                                node: node.key,
+                                messageId: 'notAsync',
+                                data: { name: node.key.name },
+                            })
+                        }
+                    },
+                }
+            },
+        },
+
+        'no-node-imports': {
+            meta: {
+                type: 'problem',
+                messages: {
+                    forbidden:
+                        'Importing "{{ source }}" in a workflow file will break the Temporal bundle. Workflows run in a sandboxed VM — Node.js built-in modules are not available.',
+                },
+            },
+            create(context) {
+                if (!isWorkflowFile(context.filename)) {
+                    return {}
+                }
+
+                return {
+                    ImportDeclaration(node) {
+                        const source = node.source.value
+
+                        if (FORBIDDEN_NODE_MODULES.has(source)) {
+                            context.report({
+                                node: node.source,
+                                messageId: 'forbidden',
+                                data: { source },
+                            })
+                        }
+                    },
+                }
+            },
+        },
+
+        'no-path-alias-imports': {
+            meta: {
+                type: 'problem',
+                messages: {
+                    forbidden:
+                        'Path alias "{{ source }}" cannot be used in workflow files. The Temporal bundler does not resolve tsconfig path aliases. Use relative imports or import only from type-only workflow packages.',
+                },
+            },
+            create(context) {
+                if (!isWorkflowFile(context.filename)) {
+                    return {}
+                }
+
+                return {
+                    ImportDeclaration(node) {
+                        if (node.importKind === 'type') {
+                            return
+                        }
+
+                        const source = node.source.value
+
+                        if (source.startsWith('@') && !source.startsWith('@diia-inhouse/') && !source.startsWith('@temporalio/')) {
+                            context.report({
+                                node: node.source,
+                                messageId: 'forbidden',
+                                data: { source },
+                            })
+                        }
+                    },
+                }
+            },
+        },
+    },
+}

package/dist/oxlint/plugins/testConventions.mjs

@@ -0,0 +1,67 @@
+const PERSISTENT_MOCK_METHODS = new Set(['mockResolvedValue', 'mockReturnValue', 'mockRejectedValue', 'mockImplementation'])
+
+function getOnceVariant(name) {
+    return `${name}Once`
+}
+
+export default {
+    meta: { name: '@diia-inhouse/oxlint-plugin-test' },
+    rules: {
+        'no-persistent-mock': {
+            meta: {
+                type: 'problem',
+                messages: {
+                    forbidden:
+                        'Use {{ once }}() instead of {{ method }}(). Persistent mocks hide test isolation issues and mask unexpected call counts.',
+                },
+            },
+            create(context) {
+                return {
+                    CallExpression(node) {
+                        if (
+                            node.callee.type === 'MemberExpression' &&
+                            node.callee.property.type === 'Identifier' &&
+                            PERSISTENT_MOCK_METHODS.has(node.callee.property.name)
+                        ) {
+                            const method = node.callee.property.name
+
+                            context.report({
+                                node: node.callee.property,
+                                messageId: 'forbidden',
+                                data: { method, once: getOnceVariant(method) },
+                            })
+                        }
+                    },
+                }
+            },
+        },
+
+        'no-vi-mock-in-workflows': {
+            meta: {
+                type: 'problem',
+                messages: {
+                    forbidden: 'vi.mock() is forbidden in workflow tests. Use mockActivities() from Temporal test utilities instead.',
+                },
+            },
+            create(context) {
+                if (!context.filename.includes('/worker/')) {
+                    return {}
+                }
+
+                return {
+                    CallExpression(node) {
+                        if (
+                            node.callee.type === 'MemberExpression' &&
+                            node.callee.object.type === 'Identifier' &&
+                            node.callee.object.name === 'vi' &&
+                            node.callee.property.type === 'Identifier' &&
+                            node.callee.property.name === 'mock'
+                        ) {
+                            context.report({ node, messageId: 'forbidden' })
+                        }
+                    },
+                }
+            },
+        },
+    },
+}

package/oxlint/plugins/classEncapsulation.mjs

@@ -0,0 +1,108 @@
+export default {
+    meta: { name: '@diia-inhouse/oxlint-plugin-class' },
+    rules: {
+        'no-module-level-const': {
+            meta: {
+                type: 'suggestion',
+                messages: {
+                    forbidden:
+                        'Module-level "{{ kind }} {{ name }}" should be a private class property. Only types, interfaces, and re-exports belong at module level alongside a class.',
+                },
+            },
+            create(context) {
+                return {
+                    'Program:exit'(programNode) {
+                        const hasDefaultClassExport = programNode.body.some(
+                            (stmt) =>
+                                stmt.type === 'ExportDefaultDeclaration' &&
+                                stmt.declaration &&
+                                stmt.declaration.type === 'ClassDeclaration',
+                        )
+
+                        if (!hasDefaultClassExport) {
+                            return
+                        }
+
+                        for (const stmt of programNode.body) {
+                            if (stmt.type !== 'VariableDeclaration') {
+                                continue
+                            }
+
+                            for (const decl of stmt.declarations) {
+                                const name = decl.id.type === 'Identifier' ? decl.id.name : '<destructured>'
+
+                                context.report({
+                                    node: decl,
+                                    messageId: 'forbidden',
+                                    data: { kind: stmt.kind, name },
+                                })
+                            }
+                        }
+                    },
+                }
+            },
+        },
+
+        'no-interface-in-implementation': {
+            meta: {
+                type: 'problem',
+                messages: {
+                    forbidden:
+                        '{{ kind }} "{{ name }}" must be in a separate file. Types and interfaces must not share a file with class implementation.',
+                },
+            },
+            create(context) {
+                return {
+                    'Program:exit'(programNode) {
+                        const hasDefaultClassExport = programNode.body.some(
+                            (stmt) =>
+                                stmt.type === 'ExportDefaultDeclaration' &&
+                                stmt.declaration &&
+                                stmt.declaration.type === 'ClassDeclaration',
+                        )
+
+                        if (!hasDefaultClassExport) {
+                            return
+                        }
+
+                        for (const stmt of programNode.body) {
+                            if (stmt.type === 'TSInterfaceDeclaration') {
+                                context.report({
+                                    node: stmt,
+                                    messageId: 'forbidden',
+                                    data: { kind: 'interface', name: stmt.id.name },
+                                })
+                            }
+
+                            if (stmt.type === 'TSTypeAliasDeclaration') {
+                                context.report({
+                                    node: stmt,
+                                    messageId: 'forbidden',
+                                    data: { kind: 'type', name: stmt.id.name },
+                                })
+                            }
+
+                            if (stmt.type === 'ExportNamedDeclaration' && stmt.declaration) {
+                                if (stmt.declaration.type === 'TSInterfaceDeclaration') {
+                                    context.report({
+                                        node: stmt.declaration,
+                                        messageId: 'forbidden',
+                                        data: { kind: 'interface', name: stmt.declaration.id.name },
+                                    })
+                                }
+
+                                if (stmt.declaration.type === 'TSTypeAliasDeclaration') {
+                                    context.report({
+                                        node: stmt.declaration,
+                                        messageId: 'forbidden',
+                                        data: { kind: 'type', name: stmt.declaration.id.name },
+                                    })
+                                }
+                            }
+                        }
+                    },
+                }
+            },
+        },
+    },
+}

package/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' })
+                            }
+                        }
+                    },
+                }
+            },
+        },
+    },
+}