@mettlecast/eslint-plugin-domain-module 0.1.0

package/README.md

@@ -0,0 +1,83 @@
+# @mettlecast/eslint-plugin-domain-module
+
+ESLint plugin enforcing TIB Domain Module framework usage patterns. Prevents accidental AWS SDK, HTTP server, and cross-domain violations.
+
+## Install
+
+```bash
+npm install --save-dev @mettlecast/eslint-plugin-domain-module
+```
+
+Configure in `eslint.config.js`:
+
+```javascript
+import domainModulePlugin from '@mettlecast/eslint-plugin-domain-module';
+
+export default [
+  {
+    files: ['src/domain/**/*.ts'],
+    ...domainModulePlugin.configs.recommended,
+  },
+];
+```
+
+## Rules
+
+| Rule | Flags | Severity |
+|---|---|---|
+| `no-raw-aws-sdk` | Direct imports of `@aws-sdk/*` packages in domain handler files | error |
+| `no-raw-http-server` | Framework imports (`express`, `koa`, `fastify`, `aws-lambda`) in domain handlers | error |
+| `require-define-primitive` | Handler files without a top-level `define*()` call (missing domain primitive declaration) | warn |
+| `no-cross-domain-internal-import` | Importing internal modules (not exported types) from another domain directory | error |
+
+## Recommended Config
+
+The `recommended` preset enables all four rules at their default severity levels:
+
+```javascript
+domainModulePlugin.configs.recommended
+// Results in:
+// - no-raw-aws-sdk: error
+// - no-raw-http-server: error
+// - require-define-primitive: warn
+// - no-cross-domain-internal-import: error
+```
+
+## Examples
+
+**Violations caught:**
+
+```typescript
+// ❌ no-raw-aws-sdk
+import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
+
+// ❌ no-raw-http-server
+import express from 'express';
+
+// ❌ require-define-primitive
+export async function chargePayment(event, ctx) { /* ... */ }
+
+// ❌ no-cross-domain-internal-import
+import { internalFn } from '../payments/internal.js'; // not in payments/index.ts
+```
+
+**Correct usage:**
+
+```typescript
+// ✓ Use DomainContext.db instead
+const { db } = ctx;
+
+// ✓ Use defineApi() to declare handlers
+export const chargeHandler = defineApi({
+  path: '/charge',
+  // ...
+});
+
+// ✓ Only import exported types from other domains
+import type { PaymentEvent } from '@myorg/payments-contracts';
+```
+
+## See Also
+
+- `@mettlecast/domain-runtime` — handler definitions
+- `@mettlecast/domain-cli` — validation and linting

package/dist/__tests__/flow-domain-ownership.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/flow-domain-ownership.test.js

@@ -0,0 +1,33 @@
+import { afterAll, describe, it } from 'vitest';
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import { flowDomainOwnership } from '../rules/flow-domain-ownership.js';
+RuleTester.afterAll = afterAll;
+RuleTester.describe = describe;
+RuleTester.it = it;
+const tester = new RuleTester({
+    languageOptions: { ecmaVersion: 2022, sourceType: 'module' },
+});
+tester.run('flow-domain-ownership', flowDomainOwnership, {
+    valid: [
+        {
+            filename: '/repo/domains/auth/flows/org-provisioning.ts',
+            code: `defineFlow({ id: 'org-provisioning', owningDomain: 'auth', name: 'x', steps: [] });`,
+        },
+        {
+            filename: '/repo/flows/root-level.ts',
+            code: `defineFlow({ id: 'root-level', name: 'x', steps: [] });`,
+        },
+    ],
+    invalid: [
+        {
+            filename: '/repo/domains/auth/flows/bad.ts',
+            code: `defineFlow({ id: 'bad', owningDomain: 'payments', name: 'x', steps: [] });`,
+            errors: [{ messageId: 'owningDomainMismatch' }],
+        },
+        {
+            filename: '/repo/domains/auth/flows/no-owner.ts',
+            code: `defineFlow({ id: 'no-owner', name: 'x', steps: [] });`,
+            errors: [{ messageId: 'missingOwningDomain' }],
+        },
+    ],
+});

package/dist/__tests__/no-cross-domain-internal-import.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/no-cross-domain-internal-import.test.js

@@ -0,0 +1,40 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import { afterAll, describe, it } from 'vitest';
+import { noCrossDomainInternalImport } from '../rules/no-cross-domain-internal-import.js';
+RuleTester.afterAll = afterAll;
+RuleTester.describe = describe;
+RuleTester.it = it;
+const tester = new RuleTester({
+    languageOptions: { ecmaVersion: 2022, sourceType: 'module' },
+});
+tester.run('no-cross-domain-internal-import', noCrossDomainInternalImport, {
+    valid: [
+        {
+            // File not in a domain directory — rule is a no-op
+            filename: '/project/src/utils/helper.ts',
+            code: "import { something } from '/project/.mc/domains/billing/api/charge.ts';",
+        },
+        {
+            // Same-domain import — allowed
+            filename: '/project/.mc/domains/billing/api/charge.ts',
+            code: "import { something } from '../subscribers/payment-received.ts';",
+        },
+        {
+            // Import from contracts package — allowed
+            filename: '/project/.mc/domains/billing/api/charge.ts',
+            code: "import { UserContracts } from '@tib-contracts/users';",
+        },
+    ],
+    invalid: [
+        {
+            filename: '/project/.mc/domains/billing/api/charge.ts',
+            code: "import { UserHandler } from '/project/.mc/domains/users/api/get-user.ts';",
+            errors: [{ messageId: 'noCrossDomainImport' }],
+        },
+        {
+            filename: '/project/.mc/domains/billing/api/charge.ts',
+            code: "import { X } from '../../users/api/handler.ts';",
+            errors: [{ messageId: 'noCrossDomainImport' }],
+        },
+    ],
+});

package/dist/__tests__/no-raw-aws-sdk.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/no-raw-aws-sdk.test.js

@@ -0,0 +1,30 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import { afterAll, describe, it } from 'vitest';
+import { noRawAwsSdk } from '../rules/no-raw-aws-sdk.js';
+RuleTester.afterAll = afterAll;
+RuleTester.describe = describe;
+RuleTester.it = it;
+const tester = new RuleTester({
+    languageOptions: { ecmaVersion: 2022, sourceType: 'module' },
+});
+tester.run('no-raw-aws-sdk', noRawAwsSdk, {
+    valid: [
+        { code: "import { something } from '@my-org/utils';" },
+        { code: "import { DomainContext } from '@mettlecast/domain-runtime';" },
+        { code: "const x = require('fs');" },
+    ],
+    invalid: [
+        {
+            code: "import { DynamoDBClient } from '@aws-sdk/client-dynamodb';",
+            errors: [{ messageId: 'noRawAwsSdk' }],
+        },
+        {
+            code: "import { S3Client } from '@aws-sdk/client-s3';",
+            errors: [{ messageId: 'noRawAwsSdk' }],
+        },
+        {
+            code: "import { EventBridgeClient } from '@aws-sdk/client-eventbridge';",
+            errors: [{ messageId: 'noRawAwsSdk' }],
+        },
+    ],
+});

package/dist/__tests__/no-raw-http-server.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/no-raw-http-server.test.js

@@ -0,0 +1,29 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import { afterAll, describe, it } from 'vitest';
+import { noRawHttpServer } from '../rules/no-raw-http-server.js';
+RuleTester.afterAll = afterAll;
+RuleTester.describe = describe;
+RuleTester.it = it;
+const tester = new RuleTester({
+    languageOptions: { ecmaVersion: 2022, sourceType: 'module' },
+});
+tester.run('no-raw-http-server', noRawHttpServer, {
+    valid: [
+        { code: "import { defineApi } from '@mettlecast/domain-runtime';" },
+        { code: "import path from 'node:path';" },
+    ],
+    invalid: [
+        {
+            code: "import express from 'express';",
+            errors: [{ messageId: 'noRawHttpServer' }],
+        },
+        {
+            code: "import Fastify from 'fastify';",
+            errors: [{ messageId: 'noRawHttpServer' }],
+        },
+        {
+            code: "import { Handler } from 'aws-lambda';",
+            errors: [{ messageId: 'noRawHttpServer' }],
+        },
+    ],
+});

package/dist/__tests__/require-define-primitive.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/require-define-primitive.test.js

@@ -0,0 +1,26 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import { afterAll, describe, it } from 'vitest';
+import { requireDefinePrimitive } from '../rules/require-define-primitive.js';
+RuleTester.afterAll = afterAll;
+RuleTester.describe = describe;
+RuleTester.it = it;
+const tester = new RuleTester({
+    languageOptions: { ecmaVersion: 2022, sourceType: 'module' },
+});
+tester.run('require-define-primitive', requireDefinePrimitive, {
+    valid: [
+        { code: "export const myApi = defineApi({ id: 'test', path: '/test' });" },
+        { code: "export const sub = defineSubscriber({ id: 'x', event: 'y', semverRange: '^1.0' });" },
+        { code: "const domain = defineDomain({ id: 'my-domain', name: 'My Domain', tenancy: 'single' });" },
+    ],
+    invalid: [
+        {
+            code: "export const SOME_CONSTANT = 'value';",
+            errors: [{ messageId: 'missingDefinePrimitive' }],
+        },
+        {
+            code: "import { something } from '@mettlecast/domain-runtime';",
+            errors: [{ messageId: 'missingDefinePrimitive' }],
+        },
+    ],
+});

package/dist/index.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @mettlecast/eslint-plugin-domain-module
+ *
+ * ESLint plugin enforcing Domain Module framework usage patterns.
+ */
+declare const _default: {
+    rules: {
+        readonly 'no-raw-aws-sdk': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noRawAwsSdk", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
+        readonly 'no-raw-http-server': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noRawHttpServer", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
+        readonly 'require-define-primitive': import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingDefinePrimitive", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
+        readonly 'no-cross-domain-internal-import': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noCrossDomainImport", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
+        readonly 'flow-domain-ownership': import("@typescript-eslint/utils/ts-eslint").RuleModule<"owningDomainMismatch" | "missingOwningDomain", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
+    };
+    configs: {
+        recommended: {
+            readonly plugins: {
+                readonly '@mettlecast/domain-module': {
+                    readonly rules: {
+                        readonly 'no-raw-aws-sdk': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noRawAwsSdk", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+                            name: string;
+                        };
+                        readonly 'no-raw-http-server': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noRawHttpServer", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+                            name: string;
+                        };
+                        readonly 'require-define-primitive': import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingDefinePrimitive", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+                            name: string;
+                        };
+                        readonly 'no-cross-domain-internal-import': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noCrossDomainImport", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+                            name: string;
+                        };
+                        readonly 'flow-domain-ownership': import("@typescript-eslint/utils/ts-eslint").RuleModule<"owningDomainMismatch" | "missingOwningDomain", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+                            name: string;
+                        };
+                    };
+                };
+            };
+            readonly rules: {
+                readonly '@mettlecast/domain-module/no-raw-aws-sdk': "error";
+                readonly '@mettlecast/domain-module/no-raw-http-server': "error";
+                readonly '@mettlecast/domain-module/require-define-primitive': "warn";
+                readonly '@mettlecast/domain-module/no-cross-domain-internal-import': "error";
+                readonly '@mettlecast/domain-module/flow-domain-ownership': "error";
+            };
+        };
+    };
+};
+export default _default;

package/dist/index.js

@@ -0,0 +1,42 @@
+import { noRawAwsSdk } from './rules/no-raw-aws-sdk.js';
+import { noRawHttpServer } from './rules/no-raw-http-server.js';
+import { requireDefinePrimitive } from './rules/require-define-primitive.js';
+import { noCrossDomainInternalImport } from './rules/no-cross-domain-internal-import.js';
+import { flowDomainOwnership } from './rules/flow-domain-ownership.js';
+/**
+ * All rules exported by @mettlecast/eslint-plugin-domain-module.
+ */
+const rules = {
+    'no-raw-aws-sdk': noRawAwsSdk,
+    'no-raw-http-server': noRawHttpServer,
+    'require-define-primitive': requireDefinePrimitive,
+    'no-cross-domain-internal-import': noCrossDomainInternalImport,
+    'flow-domain-ownership': flowDomainOwnership,
+};
+/**
+ * Recommended flat config preset.
+ * Enables all five rules at their default severity levels.
+ */
+const recommended = {
+    plugins: {
+        '@mettlecast/domain-module': { rules },
+    },
+    rules: {
+        '@mettlecast/domain-module/no-raw-aws-sdk': 'error',
+        '@mettlecast/domain-module/no-raw-http-server': 'error',
+        '@mettlecast/domain-module/require-define-primitive': 'warn',
+        '@mettlecast/domain-module/no-cross-domain-internal-import': 'error',
+        '@mettlecast/domain-module/flow-domain-ownership': 'error',
+    },
+};
+/**
+ * @mettlecast/eslint-plugin-domain-module
+ *
+ * ESLint plugin enforcing Domain Module framework usage patterns.
+ */
+export default {
+    rules,
+    configs: {
+        recommended,
+    },
+};

package/dist/rules/flow-domain-ownership.d.ts

@@ -0,0 +1,4 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export declare const flowDomainOwnership: ESLintUtils.RuleModule<"owningDomainMismatch" | "missingOwningDomain", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};

package/dist/rules/flow-domain-ownership.js

@@ -0,0 +1,45 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+const createRule = ESLintUtils.RuleCreator((name) => `https://github.com/LawrenceGeeHouse/Mettlecast/blob/develop/packages/eslint-plugin-domain-module/docs/${name}.md`);
+function extractOwningDomainFromPath(filePath) {
+    const match = /[/\\]domains[/\\]([^/\\]+)[/\\]flows[/\\]/.exec(filePath);
+    return match?.[1];
+}
+export const flowDomainOwnership = createRule({
+    name: 'flow-domain-ownership',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'A flow file in domains/{x}/flows/ must declare owningDomain matching x.',
+        },
+        messages: {
+            owningDomainMismatch: 'Flow owningDomain "{{declared}}" does not match directory domain "{{expected}}". Move the file or fix owningDomain.\n  fixHint: Either move the flow file to domains/{{declared}}/flows/ or change owningDomain to \'{{expected}}\'.\n  kNodeRef: K:convention:flow-vs-subscriber-rule',
+            missingOwningDomain: 'Flow in domains/{{expected}}/flows/ must declare owningDomain: \'{{expected}}\'.\n  fixHint: Add `owningDomain: \'{{expected}}\'` to the defineFlow() call.\n  kNodeRef: K:convention:flow-vs-subscriber-rule',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        const filename = context.filename ?? context.getFilename?.() ?? '';
+        const expectedDomain = extractOwningDomainFromPath(filename);
+        if (!expectedDomain)
+            return {};
+        return {
+            CallExpression(node) {
+                if (node.callee.type !== 'Identifier' || node.callee.name !== 'defineFlow')
+                    return;
+                const arg = node.arguments[0];
+                if (!arg || arg.type !== 'ObjectExpression')
+                    return;
+                const owningDomainProp = arg.properties.find((p) => p.type === 'Property' && 'name' in p.key && p.key.name === 'owningDomain');
+                if (!owningDomainProp) {
+                    context.report({ node, messageId: 'missingOwningDomain', data: { expected: expectedDomain } });
+                    return;
+                }
+                const val = owningDomainProp.value;
+                if (val.type === 'Literal' && typeof val.value === 'string' && val.value !== expectedDomain) {
+                    context.report({ node, messageId: 'owningDomainMismatch', data: { declared: val.value, expected: expectedDomain } });
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-cross-domain-internal-import.d.ts

@@ -0,0 +1,4 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export declare const noCrossDomainInternalImport: ESLintUtils.RuleModule<"noCrossDomainImport", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};

package/dist/rules/no-cross-domain-internal-import.js

@@ -0,0 +1,47 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+import { resolve, dirname } from 'node:path';
+const createRule = ESLintUtils.RuleCreator((name) => `https://github.com/LawrenceGeeHouse/Mettlecast/blob/develop/packages/eslint-plugin-domain-module/docs/${name}.md`);
+function extractDomainName(filePath) {
+    const match = /[/\\]\.tib[/\\]domains[/\\]([^/\\]+)[/\\]/.exec(filePath);
+    return match?.[1];
+}
+export const noCrossDomainInternalImport = createRule({
+    name: 'no-cross-domain-internal-import',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow direct imports from another domain directory. Use ctx.actions.<domain> or contracts package instead.',
+        },
+        messages: {
+            noCrossDomainImport: 'Cross-domain import "{{source}}" is not allowed. Use ctx.actions.{{targetDomain}} or import from the contracts package.\n  fixHint: Replace direct import with `await ctx.actions.call(\'{{targetDomain}}.<action>\', params)` or import from the contracts package.\n  kNodeRef: K:convention:no-cross-domain-import',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        const filename = context.filename ?? context.getFilename?.() ?? '';
+        const currentDomain = extractDomainName(filename);
+        if (!currentDomain)
+            return {};
+        return {
+            ImportDeclaration(node) {
+                const source = node.source.value;
+                if (typeof source !== 'string')
+                    return;
+                const absMatch = /[/\\]\.tib[/\\]domains[/\\]([^/\\]+)[/\\]/.exec(source);
+                if (absMatch?.[1] && absMatch[1] !== currentDomain) {
+                    context.report({ node, messageId: 'noCrossDomainImport', data: { source, targetDomain: absMatch[1] } });
+                    return;
+                }
+                if (source.startsWith('.')) {
+                    const fileDir = dirname(filename);
+                    const resolvedPath = resolve(fileDir, source);
+                    const relMatch = /[/\\]\.tib[/\\]domains[/\\]([^/\\]+)[/\\]/.exec(resolvedPath);
+                    if (relMatch?.[1] && relMatch[1] !== currentDomain) {
+                        context.report({ node, messageId: 'noCrossDomainImport', data: { source, targetDomain: relMatch[1] } });
+                    }
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-raw-aws-sdk.d.ts

@@ -0,0 +1,4 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export declare const noRawAwsSdk: ESLintUtils.RuleModule<"noRawAwsSdk", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};

package/dist/rules/no-raw-aws-sdk.js

@@ -0,0 +1,26 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+const createRule = ESLintUtils.RuleCreator((name) => `https://github.com/LawrenceGeeHouse/Mettlecast/blob/develop/packages/eslint-plugin-domain-module/docs/${name}.md`);
+export const noRawAwsSdk = createRule({
+    name: 'no-raw-aws-sdk',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow direct @aws-sdk/* imports in domain handler files. Use ctx.* instead.',
+        },
+        messages: {
+            noRawAwsSdk: 'Direct AWS SDK import "{{source}}" is not allowed in domain handlers. Use ctx.* methods provided by DomainContext.\n  fixHint: Replace `import ... from \'{{source}}\'` with the corresponding `ctx.*` method (e.g., ctx.db for DynamoDB, ctx.publish for EventBridge).\n  kNodeRef: K:convention:tier-1-foundations',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            ImportDeclaration(node) {
+                const source = node.source.value;
+                if (typeof source === 'string' && /^@aws-sdk\//.test(source)) {
+                    context.report({ node, messageId: 'noRawAwsSdk', data: { source } });
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-raw-http-server.d.ts

@@ -0,0 +1,4 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export declare const noRawHttpServer: ESLintUtils.RuleModule<"noRawHttpServer", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};

package/dist/rules/no-raw-http-server.js

@@ -0,0 +1,27 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+const createRule = ESLintUtils.RuleCreator((name) => `https://github.com/LawrenceGeeHouse/Mettlecast/blob/develop/packages/eslint-plugin-domain-module/docs/${name}.md`);
+const BANNED_HTTP_PACKAGES = new Set(['express', 'koa', 'fastify', 'aws-lambda']);
+export const noRawHttpServer = createRule({
+    name: 'no-raw-http-server',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow HTTP server framework imports (express, koa, fastify, aws-lambda) in domain files.',
+        },
+        messages: {
+            noRawHttpServer: 'HTTP framework import "{{source}}" is not allowed in domain files. The Domain Module runtime handles transport binding.\n  fixHint: Remove the `{{source}}` import. Domain primitives (defineApi, defineWebhook) are transport-agnostic — the runtime handles HTTP binding.\n  kNodeRef: K:convention:tier-1-foundations',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            ImportDeclaration(node) {
+                const source = node.source.value;
+                if (typeof source === 'string' && BANNED_HTTP_PACKAGES.has(source)) {
+                    context.report({ node, messageId: 'noRawHttpServer', data: { source } });
+                }
+            },
+        };
+    },
+});

package/dist/rules/require-define-primitive.d.ts

@@ -0,0 +1,4 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export declare const requireDefinePrimitive: ESLintUtils.RuleModule<"missingDefinePrimitive", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};

package/dist/rules/require-define-primitive.js

@@ -0,0 +1,36 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+const createRule = ESLintUtils.RuleCreator((name) => `https://github.com/LawrenceGeeHouse/Mettlecast/blob/develop/packages/eslint-plugin-domain-module/docs/${name}.md`);
+const DEFINE_CALLS = new Set([
+    'defineApi', 'defineWebhook', 'defineSubscriber', 'defineSchedule',
+    'defineJob', 'defineAction', 'defineIntegration', 'defineEvent', 'defineDomain',
+]);
+export const requireDefinePrimitive = createRule({
+    name: 'require-define-primitive',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Domain primitive files must export at least one define*() call result.',
+        },
+        messages: {
+            missingDefinePrimitive: 'No define*() call found in this domain primitive file. Export at least one defineApi(), defineWebhook(), defineSubscriber(), etc.\n  fixHint: Wrap the file\'s export in a define*() call (e.g., `export const handler = defineApi({...})`). See domain.config.ts for the list of available primitives.\n  kNodeRef: K:runbook:add-domain',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        let foundDefineCall = false;
+        return {
+            CallExpression(node) {
+                const callee = node.callee;
+                if (callee.type === 'Identifier' && DEFINE_CALLS.has(callee.name)) {
+                    foundDefineCall = true;
+                }
+            },
+            'Program:exit'(node) {
+                if (!foundDefineCall) {
+                    context.report({ node, messageId: 'missingDefinePrimitive' });
+                }
+            },
+        };
+    },
+});

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@mettlecast/eslint-plugin-domain-module",
+  "version": "0.1.0",
+  "type": "module",
+  "files": ["dist"],
+  "exports": {
+    ".": { "types": "./dist/index.d.ts", "default": "./dist/index.js" }
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "test": "vitest"
+  },
+  "peerDependencies": {
+    "eslint": "^9.0.0"
+  },
+  "dependencies": {
+    "@typescript-eslint/utils": "^8.0.0"
+  },
+  "devDependencies": {
+    "@types/eslint": "^9.0.0",
+    "@types/node": "^20.0.0",
+    "@typescript-eslint/rule-tester": "^8.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^2.0.0"
+  }
+}