@diia-inhouse/oxc-config 1.9.2

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

package/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/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/package.json

@@ -0,0 +1,68 @@
+{
+    "name": "@diia-inhouse/oxc-config",
+    "version": "1.9.2",
+    "description": "OXC toolchain configs for Diia services: oxlint, oxfmt, oxc transformer",
+    "author": "Diia",
+    "license": "SEE LICENSE IN LICENSE.md",
+    "type": "module",
+    "bin": {
+        "diia-dev": "./bin/dev.mjs"
+    },
+    "exports": {
+        "./oxlint": "./dist/oxlint/config.js",
+        "./oxfmt": "./dist/oxfmt.config.js"
+    },
+    "files": [
+        "dist",
+        "oxlint/plugins",
+        "bin"
+    ],
+    "engines": {
+        "node": ">=22"
+    },
+    "scripts": {
+        "test": "vitest run",
+        "build": "tsc -p tsconfig.build.json && cp -r oxlint/plugins dist/oxlint/plugins",
+        "prepare": "npm run build",
+        "lint": "oxlint && oxfmt --check",
+        "lint-fix": "oxlint --fix && oxfmt",
+        "find-circulars": "madge --circular --extensions ts ./",
+        "lint:lockfile": "lockfile-lint --path package-lock.json --allowed-hosts registry.npmjs.org --validate-https",
+        "semantic-release": "semantic-release"
+    },
+    "dependencies": {
+        "@boundaries/eslint-plugin": "6.0.2",
+        "@diia-inhouse/eslint-plugin": "1.9.6",
+        "@stylistic/eslint-plugin": "5.10.0",
+        "eslint-import-resolver-oxc": "0.15.0",
+        "eslint-plugin-regexp": "3.1.0",
+        "eslint-plugin-security": "4.0.0",
+        "tsx": "4.21.0"
+    },
+    "peerDependencies": {
+        "oxfmt": ">= 0.43.0",
+        "oxlint": ">= 1.58.0",
+        "oxlint-tsgolint": ">= 0.20.0"
+    },
+    "devDependencies": {
+        "@diia-inhouse/configs": "6.1.1",
+        "@typescript-eslint/parser": "8.59.1",
+        "@typescript-eslint/rule-tester": "8.59.1",
+        "@vitest/coverage-v8": "4.1.5",
+        "@vitest/ui": "4.1.5",
+        "lockfile-lint": "5.0.0",
+        "madge": "8.0.0",
+        "oxfmt": "0.47.0",
+        "oxlint": "1.62.0",
+        "oxlint-tsgolint": "0.22.1",
+        "semantic-release": "24.2.7",
+        "vitest": "4.1.5"
+    },
+    "commitlint": {
+        "extends": "@diia-inhouse/configs/dist/commitlint"
+    },
+    "release": {
+        "extends": "@diia-inhouse/configs/dist/semantic-release/package"
+    },
+    "repository": "https://github.com/diia-open-source/be-oxc-config"
+}