@monoes/monograph 1.5.6 → 1.5.8

package/__tests__/pipeline/phases/field-access.test.ts

@@ -1,22 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { extractFieldAccesses } from '../../../src/pipeline/phases/field-access.js';
-
-describe('extractFieldAccesses', () => {
-  it('detects property reads', () => {
-    const src = `function greet(user: User) { return user.name; }`;
-    const accesses = extractFieldAccesses(src, 'user', 'src/a.ts');
-    expect(accesses.some(a => a.field === 'name' && a.reason === 'read')).toBe(true);
-  });
-
-  it('detects property writes', () => {
-    const src = `function update(obj: Obj) { obj.count = 1; obj.total += 5; }`;
-    const accesses = extractFieldAccesses(src, 'obj', 'src/a.ts');
-    expect(accesses.some(a => a.field === 'count' && a.reason === 'write')).toBe(true);
-    expect(accesses.some(a => a.field === 'total' && a.reason === 'write')).toBe(true);
-  });
-
-  it('returns empty when no accesses found', () => {
-    const src = `function noop() { return 42; }`;
-    expect(extractFieldAccesses(src, 'obj', 'src/a.ts')).toHaveLength(0);
-  });
-});

package/__tests__/pipeline/phases/leiden.test.ts

@@ -1,72 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import Graph from 'graphology';
-import { leiden } from '../../../src/pipeline/phases/leiden.js';
-
-function makeClusteredGraph(): Graph {
-  const graph = new Graph({ type: 'undirected' });
-  // Cluster A: a-b-c tightly connected
-  graph.addNode('a');
-  graph.addNode('b');
-  graph.addNode('c');
-  graph.addEdge('a', 'b');
-  graph.addEdge('b', 'c');
-  graph.addEdge('a', 'c');
-  // Cluster B: x-y-z tightly connected
-  graph.addNode('x');
-  graph.addNode('y');
-  graph.addNode('z');
-  graph.addEdge('x', 'y');
-  graph.addEdge('y', 'z');
-  graph.addEdge('x', 'z');
-  // Weak bridge between clusters
-  graph.addEdge('c', 'x');
-  return graph;
-}
-
-describe('leiden', () => {
-  it('produces deterministic results on repeated calls', () => {
-    const graph = makeClusteredGraph();
-    const result1 = leiden(graph, { seed: 42 });
-    const result2 = leiden(graph, { seed: 42 });
-    expect(result1).toEqual(result2);
-  });
-
-  it('returns a community assignment for every node', () => {
-    const graph = makeClusteredGraph();
-    const result = leiden(graph);
-    const nodes = graph.nodes();
-    expect(Object.keys(result).length).toBe(nodes.length);
-    for (const node of nodes) {
-      expect(result[node]).toBeDefined();
-    }
-  });
-
-  it('returns at least 1 community for a two-node graph', () => {
-    const graph = new Graph({ type: 'undirected' });
-    graph.addNode('a');
-    graph.addNode('b');
-    graph.addEdge('a', 'b');
-    const result = leiden(graph);
-    const communityIds = new Set(Object.values(result));
-    expect(communityIds.size).toBeGreaterThanOrEqual(1);
-    expect(Object.keys(result).length).toBe(2);
-  });
-
-  it('handles an empty graph without crashing', () => {
-    const graph = new Graph({ type: 'undirected' });
-    expect(() => leiden(graph)).not.toThrow();
-    expect(leiden(graph)).toEqual({});
-  });
-
-  it('works with directed graphs (as louvain-based)', () => {
-    const graph = new Graph({ type: 'directed' });
-    graph.addNode('a');
-    graph.addNode('b');
-    graph.addNode('c');
-    graph.addEdge('a', 'b');
-    graph.addEdge('b', 'c');
-    graph.addEdge('c', 'a');
-    const result = leiden(graph);
-    expect(Object.keys(result).length).toBe(3);
-  });
-});

package/__tests__/pipeline/phases/markdown.test.ts

@@ -1,84 +0,0 @@
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { mkdirSync, writeFileSync, rmSync, existsSync } from 'fs';
-import { buildAsync } from '../../../src/pipeline/orchestrator.js';
-import { openDb, closeDb } from '../../../src/storage/db.js';
-import { getNodesForFile } from '../../../src/storage/node-store.js';
-import { getEdgesForSource } from '../../../src/storage/edge-store.js';
-
-const base = join(tmpdir(), `monograph-markdown-test-${Date.now()}`);
-const dbPath = join(base, '.monomind', 'monograph.db');
-
-beforeAll(async () => {
-  mkdirSync(join(base, 'src'), { recursive: true });
-
-  // TypeScript fixture — parser must extract a Function node named 'helper'
-  writeFileSync(
-    join(base, 'src', 'util.ts'),
-    `export function helper(): void {\n  return;\n}\n`,
-  );
-
-  // Markdown fixture referencing the function by inline code span
-  writeFileSync(
-    join(base, 'README.md'),
-    `# Usage\n\nCall \`helper\` to do things.\n`,
-  );
-
-  await buildAsync(base);
-}, 60000);
-
-afterAll(() => rmSync(base, { recursive: true, force: true }));
-
-describe('markdown phase', () => {
-  it('creates the SQLite database', () => {
-    expect(existsSync(dbPath)).toBe(true);
-  });
-
-  it('creates a Document node for the markdown file', () => {
-    const db = openDb(dbPath);
-    try {
-      const nodes = getNodesForFile(db, 'README.md');
-      const doc = nodes.find(n => n.label === 'Document');
-      expect(doc).toBeDefined();
-      expect(doc!.name).toBe('README');
-      expect(doc!.language).toBe('markdown');
-    } finally {
-      closeDb(db);
-    }
-  });
-
-  it('creates a REFERENCES edge from the Document node to the function node', () => {
-    const db = openDb(dbPath);
-    try {
-      const docNodes = getNodesForFile(db, 'README.md');
-      const doc = docNodes.find(n => n.label === 'Document');
-      expect(doc).toBeDefined();
-
-      const edges = getEdgesForSource(db, doc!.id);
-      const refEdge = edges.find(e => e.relation === 'REFERENCES');
-      expect(refEdge).toBeDefined();
-      expect(refEdge!.confidence).toBe('INFERRED');
-      expect(refEdge!.confidenceScore).toBe(0.8);
-
-      // The target should be the 'helper' function node
-      const helperRow = db
-        .prepare(`SELECT id FROM nodes WHERE name = 'helper' AND label = 'Function'`)
-        .get() as { id: string } | undefined;
-      expect(helperRow).toBeDefined();
-      expect(refEdge!.targetId).toBe(helperRow!.id);
-    } finally {
-      closeDb(db);
-    }
-  });
-
-  it('does not crash when no markdown files exist', async () => {
-    const noMdDir = join(tmpdir(), `monograph-nomd-${Date.now()}`);
-    mkdirSync(join(noMdDir, 'src'), { recursive: true });
-    writeFileSync(join(noMdDir, 'src', 'index.ts'), 'export const x = 1;\n');
-    try {
-      await expect(buildAsync(noMdDir)).resolves.not.toThrow();
-    } finally {
-      rmSync(noMdDir, { recursive: true, force: true });
-    }
-  }, 60000);
-});

package/__tests__/pipeline/phases/middleware-extractor.test.ts

@@ -1,131 +0,0 @@
-import { extractMiddlewareChain } from '../../../src/pipeline/phases/middleware-extractor.js';
-
-describe('extractMiddlewareChain', () => {
-  // ── Pattern: none ─────────────────────────────────────────────────────────
-
-  it('returns empty array and pattern none for a plain handler with no wrapping', () => {
-    const source = `
-      export default function handler(req, res) {
-        res.send('ok');
-      }
-    `;
-    const result = extractMiddlewareChain(source, 'handler');
-    expect(result.middlewareNames).toEqual([]);
-    expect(result.wrapperPattern).toBe('none');
-  });
-
-  // ── Pattern: nested ───────────────────────────────────────────────────────
-
-  it('detects single wrapper: withAuth(handler)', () => {
-    const source = `export default withAuth(handler);`;
-    const result = extractMiddlewareChain(source, 'handler');
-    expect(result.middlewareNames).toEqual(['withAuth']);
-    expect(result.wrapperPattern).toBe('nested');
-  });
-
-  it('detects nested wrappers outermost-first: withAuth(withRateLimit(handler))', () => {
-    const source = `export default withAuth(withRateLimit(handler));`;
-    const result = extractMiddlewareChain(source, 'handler');
-    expect(result.middlewareNames).toEqual(['withAuth', 'withRateLimit']);
-    expect(result.wrapperPattern).toBe('nested');
-  });
-
-  it('handles three-level nesting: withA(withB(withC(handler)))', () => {
-    const source = `module.exports = withA(withB(withC(handler)));`;
-    const result = extractMiddlewareChain(source, 'handler');
-    expect(result.middlewareNames).toEqual(['withA', 'withB', 'withC']);
-    expect(result.wrapperPattern).toBe('nested');
-  });
-
-  // ── Pattern: compose ──────────────────────────────────────────────────────
-
-  it('detects compose pattern: compose(withAuth, rateLimit)(handler)', () => {
-    const source = `export default compose(withAuth, rateLimit)(handler);`;
-    const result = extractMiddlewareChain(source, 'handler');
-    expect(result.middlewareNames).toEqual(['withAuth', 'rateLimit']);
-    expect(result.wrapperPattern).toBe('compose');
-  });
-
-  it('detects pipe pattern: pipe(authMiddleware, rateLimitMiddleware)(handler)', () => {
-    const source = `const routeHandler = pipe(authMiddleware, rateLimitMiddleware)(handler);`;
-    const result = extractMiddlewareChain(source, 'handler');
-    expect(result.middlewareNames).toEqual(['authMiddleware', 'rateLimitMiddleware']);
-    expect(result.wrapperPattern).toBe('compose');
-  });
-
-  it('compose with three middlewares', () => {
-    const source = `export default compose(withAuth, withLogging, withRateLimit)(handler);`;
-    const result = extractMiddlewareChain(source, 'handler');
-    expect(result.middlewareNames).toEqual(['withAuth', 'withLogging', 'withRateLimit']);
-    expect(result.wrapperPattern).toBe('compose');
-  });
-
-  // ── Pattern: array (Express-style positional args) ────────────────────────
-
-  it('detects Express positional middleware before handler', () => {
-    const source = `
-      app.get('/users', authMiddleware, handler);
-    `;
-    const result = extractMiddlewareChain(source, 'handler');
-    expect(result.middlewareNames).toEqual(['authMiddleware']);
-    expect(result.wrapperPattern).toBe('array');
-  });
-
-  it('detects multiple Express positional middlewares', () => {
-    const source = `
-      router.post('/login', rateLimiter, validateBody, handler);
-    `;
-    const result = extractMiddlewareChain(source, 'handler');
-    expect(result.middlewareNames).toEqual(['rateLimiter', 'validateBody']);
-    expect(result.wrapperPattern).toBe('array');
-  });
-
-  // ── Pattern: Next.js middleware.ts ────────────────────────────────────────
-
-  it('detects Next.js middleware file with matcher config', () => {
-    const source = `
-      import { NextResponse } from 'next/server';
-
-      export function middleware(req) {
-        return NextResponse.next();
-      }
-
-      export const config = {
-        matcher: ['/api/:path*'],
-      };
-    `;
-    // handlerName doesn't matter for this detection
-    const result = extractMiddlewareChain(source, 'middleware');
-    expect(result.middlewareNames).toEqual(['middleware.ts']);
-    expect(result.wrapperPattern).toBe('none');
-  });
-
-  it('Next.js middleware with default export and matcher', () => {
-    const source = `
-      export default async function middleware(request) {
-        return null;
-      }
-      export const config = { matcher: '/admin' };
-    `;
-    const result = extractMiddlewareChain(source, 'someHandler');
-    expect(result.middlewareNames).toEqual(['middleware.ts']);
-    expect(result.wrapperPattern).toBe('none');
-  });
-
-  // ── Edge cases ────────────────────────────────────────────────────────────
-
-  it('returns empty when handler name does not appear in source', () => {
-    const source = `app.get('/foo', someOtherHandler);`;
-    const result = extractMiddlewareChain(source, 'handler');
-    expect(result.middlewareNames).toEqual([]);
-    expect(result.wrapperPattern).toBe('none');
-  });
-
-  it('only scans first 3000 characters', () => {
-    const padding = 'x'.repeat(2990);
-    const source = `${padding}\nexport default withAuth(handler);`;
-    // handlerName appears past the 3000-char limit — should not be found
-    const result = extractMiddlewareChain(source, 'handler');
-    expect(result.middlewareNames).toEqual([]);
-  });
-});

package/__tests__/pipeline/phases/orm.test.ts

@@ -1,379 +0,0 @@
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { mkdirSync, writeFileSync, rmSync, existsSync } from 'fs';
-import { buildAsync } from '../../../src/pipeline/orchestrator.js';
-import { openDb, closeDb } from '../../../src/storage/db.js';
-
-// ── TypeORM ───────────────────────────────────────────────────────────────────
-
-describe('orm phase — TypeORM @Entity()', () => {
-  const base = join(tmpdir(), `monograph-orm-typeorm-${Date.now()}`);
-  const dbPath = join(base, '.monomind', 'monograph.db');
-
-  beforeAll(async () => {
-    mkdirSync(join(base, 'src'), { recursive: true });
-
-    writeFileSync(
-      join(base, 'src', 'user.entity.ts'),
-      [
-        `import { Entity, Column, PrimaryGeneratedColumn } from 'typeorm';`,
-        ``,
-        `@Entity()`,
-        `export class User {`,
-        `  @PrimaryGeneratedColumn()`,
-        `  id: number;`,
-        ``,
-        `  @Column()`,
-        `  name: string;`,
-        ``,
-        `  @Column()`,
-        `  email: string;`,
-        `}`,
-      ].join('\n') + '\n',
-    );
-
-    await buildAsync(base);
-  }, 60000);
-
-  afterAll(() => rmSync(base, { recursive: true, force: true }));
-
-  it('creates the SQLite database', () => {
-    expect(existsSync(dbPath)).toBe(true);
-  });
-
-  it('creates an Entity node for the User class', () => {
-    const db = openDb(dbPath);
-    try {
-      const row = db
-        .prepare(`SELECT * FROM nodes WHERE label = 'Entity' AND name = 'User'`)
-        .get() as { name: string; file_path: string } | undefined;
-      expect(row).toBeDefined();
-      expect(row!.name).toBe('User');
-    } finally {
-      closeDb(db);
-    }
-  });
-
-  it('creates Field nodes for decorated columns', () => {
-    const db = openDb(dbPath);
-    try {
-      const rows = db
-        .prepare(`SELECT name FROM nodes WHERE label = 'Field'`)
-        .all() as { name: string }[];
-      const names = rows.map(r => r.name);
-      // At least some column fields should be detected
-      expect(names.length).toBeGreaterThan(0);
-    } finally {
-      closeDb(db);
-    }
-  });
-
-  it('creates HAS_FIELD edges from Entity to Field nodes', () => {
-    const db = openDb(dbPath);
-    try {
-      const row = db
-        .prepare(`SELECT * FROM edges WHERE relation = 'HAS_FIELD' LIMIT 1`)
-        .get() as { relation: string } | undefined;
-      expect(row).toBeDefined();
-    } finally {
-      closeDb(db);
-    }
-  });
-});
-
-// ── Prisma ────────────────────────────────────────────────────────────────────
-
-describe('orm phase — Prisma schema.prisma', () => {
-  const base = join(tmpdir(), `monograph-orm-prisma-${Date.now()}`);
-  const dbPath = join(base, '.monomind', 'monograph.db');
-
-  beforeAll(async () => {
-    mkdirSync(base, { recursive: true });
-
-    writeFileSync(
-      join(base, 'schema.prisma'),
-      [
-        `datasource db {`,
-        `  provider = "postgresql"`,
-        `  url      = env("DATABASE_URL")`,
-        `}`,
-        ``,
-        `model Post {`,
-        `  id        Int     @id @default(autoincrement())`,
-        `  title     String`,
-        `  content   String?`,
-        `  published Boolean @default(false)`,
-        `}`,
-      ].join('\n') + '\n',
-    );
-
-    await buildAsync(base);
-  }, 60000);
-
-  afterAll(() => rmSync(base, { recursive: true, force: true }));
-
-  it('creates the SQLite database', () => {
-    expect(existsSync(dbPath)).toBe(true);
-  });
-
-  it('creates an Entity node for the Prisma model', () => {
-    const db = openDb(dbPath);
-    try {
-      const row = db
-        .prepare(`SELECT * FROM nodes WHERE label = 'Entity' AND name = 'Post'`)
-        .get() as { name: string } | undefined;
-      expect(row).toBeDefined();
-      expect(row!.name).toBe('Post');
-    } finally {
-      closeDb(db);
-    }
-  });
-
-  it('creates Field nodes for Prisma model fields', () => {
-    const db = openDb(dbPath);
-    try {
-      const rows = db
-        .prepare(`SELECT name FROM nodes WHERE label = 'Field'`)
-        .all() as { name: string }[];
-      const names = rows.map(r => r.name);
-      expect(names).toContain('title');
-    } finally {
-      closeDb(db);
-    }
-  });
-});
-
-// ── Mongoose ──────────────────────────────────────────────────────────────────
-
-describe('orm phase — Mongoose new Schema()', () => {
-  const base = join(tmpdir(), `monograph-orm-mongoose-${Date.now()}`);
-  const dbPath = join(base, '.monomind', 'monograph.db');
-
-  beforeAll(async () => {
-    mkdirSync(join(base, 'src'), { recursive: true });
-
-    writeFileSync(
-      join(base, 'src', 'product.model.js'),
-      [
-        `const mongoose = require('mongoose');`,
-        `const { Schema } = mongoose;`,
-        ``,
-        `const productSchema = new Schema({`,
-        `  title: { type: String, required: true },`,
-        `  price: { type: Number },`,
-        `  inStock: Boolean,`,
-        `});`,
-        ``,
-        `module.exports = mongoose.model('Product', productSchema);`,
-      ].join('\n') + '\n',
-    );
-
-    await buildAsync(base);
-  }, 60000);
-
-  afterAll(() => rmSync(base, { recursive: true, force: true }));
-
-  it('creates the SQLite database', () => {
-    expect(existsSync(dbPath)).toBe(true);
-  });
-
-  it('creates an Entity node from the Mongoose schema variable', () => {
-    const db = openDb(dbPath);
-    try {
-      const row = db
-        .prepare(`SELECT * FROM nodes WHERE label = 'Entity' AND name = 'product'`)
-        .get() as { name: string } | undefined;
-      expect(row).toBeDefined();
-    } finally {
-      closeDb(db);
-    }
-  });
-});
-
-// ── Sequelize ─────────────────────────────────────────────────────────────────
-
-describe('orm phase — Sequelize Model.init()', () => {
-  const base = join(tmpdir(), `monograph-orm-sequelize-init-${Date.now()}`);
-  const dbPath = join(base, '.monomind', 'monograph.db');
-
-  beforeAll(async () => {
-    mkdirSync(join(base, 'src'), { recursive: true });
-
-    writeFileSync(
-      join(base, 'src', 'order.model.ts'),
-      [
-        `import { Model, DataTypes, Sequelize } from 'sequelize';`,
-        ``,
-        `class Order extends Model {}`,
-        ``,
-        `Order.init(`,
-        `  {`,
-        `    id: { type: DataTypes.INTEGER, primaryKey: true },`,
-        `    total: { type: DataTypes.DECIMAL },`,
-        `    status: DataTypes.STRING,`,
-        `  },`,
-        `  { sequelize, tableName: 'orders' },`,
-        `);`,
-        ``,
-        `export { Order };`,
-      ].join('\n') + '\n',
-    );
-
-    await buildAsync(base);
-  }, 60000);
-
-  afterAll(() => rmSync(base, { recursive: true, force: true }));
-
-  it('creates the SQLite database', () => {
-    expect(existsSync(dbPath)).toBe(true);
-  });
-
-  it('creates an Entity node for the Sequelize Model subclass', () => {
-    const db = openDb(dbPath);
-    try {
-      const row = db
-        .prepare(`SELECT * FROM nodes WHERE label = 'Entity' AND name = 'Order'`)
-        .get() as { name: string } | undefined;
-      expect(row).toBeDefined();
-      expect(row!.name).toBe('Order');
-    } finally {
-      closeDb(db);
-    }
-  });
-
-  it('creates Field nodes for Sequelize columns', () => {
-    const db = openDb(dbPath);
-    try {
-      const rows = db
-        .prepare(`SELECT name FROM nodes WHERE label = 'Field'`)
-        .all() as { name: string }[];
-      const names = rows.map(r => r.name);
-      expect(names.length).toBeGreaterThan(0);
-    } finally {
-      closeDb(db);
-    }
-  });
-});
-
-describe('orm phase — Sequelize sequelize.define()', () => {
-  const base = join(tmpdir(), `monograph-orm-sequelize-define-${Date.now()}`);
-  const dbPath = join(base, '.monomind', 'monograph.db');
-
-  beforeAll(async () => {
-    mkdirSync(join(base, 'src'), { recursive: true });
-
-    writeFileSync(
-      join(base, 'src', 'product.js'),
-      [
-        `const { DataTypes } = require('sequelize');`,
-        ``,
-        `const Product = sequelize.define('Product', {`,
-        `  name: DataTypes.STRING,`,
-        `  price: { type: DataTypes.FLOAT },`,
-        `  sku: DataTypes.STRING,`,
-        `});`,
-        ``,
-        `module.exports = Product;`,
-      ].join('\n') + '\n',
-    );
-
-    await buildAsync(base);
-  }, 60000);
-
-  afterAll(() => rmSync(base, { recursive: true, force: true }));
-
-  it('creates the SQLite database', () => {
-    expect(existsSync(dbPath)).toBe(true);
-  });
-
-  it('creates an Entity node from sequelize.define()', () => {
-    const db = openDb(dbPath);
-    try {
-      const row = db
-        .prepare(`SELECT * FROM nodes WHERE label = 'Entity' AND name = 'Product'`)
-        .get() as { name: string } | undefined;
-      expect(row).toBeDefined();
-    } finally {
-      closeDb(db);
-    }
-  });
-});
-
-// ── MikroORM ──────────────────────────────────────────────────────────────────
-
-describe('orm phase — MikroORM @Entity() with @Property()', () => {
-  const base = join(tmpdir(), `monograph-orm-mikro-${Date.now()}`);
-  const dbPath = join(base, '.monomind', 'monograph.db');
-
-  beforeAll(async () => {
-    mkdirSync(join(base, 'src'), { recursive: true });
-
-    writeFileSync(
-      join(base, 'src', 'book.entity.ts'),
-      [
-        `import { Entity, PrimaryKey, Property, ManyToOne } from '@mikro-orm/core';`,
-        ``,
-        `@Entity()`,
-        `export class Book {`,
-        `  @PrimaryKey()`,
-        `  id!: number;`,
-        ``,
-        `  @Property()`,
-        `  title!: string;`,
-        ``,
-        `  @Property()`,
-        `  isbn!: string;`,
-        `}`,
-      ].join('\n') + '\n',
-    );
-
-    await buildAsync(base);
-  }, 60000);
-
-  afterAll(() => rmSync(base, { recursive: true, force: true }));
-
-  it('creates the SQLite database', () => {
-    expect(existsSync(dbPath)).toBe(true);
-  });
-
-  it('creates an Entity node for the MikroORM entity class', () => {
-    const db = openDb(dbPath);
-    try {
-      const row = db
-        .prepare(`SELECT * FROM nodes WHERE label = 'Entity' AND name = 'Book'`)
-        .get() as { name: string } | undefined;
-      expect(row).toBeDefined();
-      expect(row!.name).toBe('Book');
-    } finally {
-      closeDb(db);
-    }
-  });
-
-  it('creates Field nodes for @Property() decorated fields', () => {
-    const db = openDb(dbPath);
-    try {
-      const rows = db
-        .prepare(`SELECT name FROM nodes WHERE label = 'Field'`)
-        .all() as { name: string }[];
-      const names = rows.map(r => r.name);
-      expect(names.length).toBeGreaterThan(0);
-    } finally {
-      closeDb(db);
-    }
-  });
-});
-
-// ── No ORM patterns ───────────────────────────────────────────────────────────
-
-describe('orm phase — no ORM patterns', () => {
-  it('does not crash when no ORM patterns are detected', async () => {
-    const noOrmDir = join(tmpdir(), `monograph-no-orm-${Date.now()}`);
-    mkdirSync(join(noOrmDir, 'src'), { recursive: true });
-    writeFileSync(join(noOrmDir, 'src', 'index.ts'), 'export const x = 42;\n');
-    try {
-      await expect(buildAsync(noOrmDir)).resolves.not.toThrow();
-    } finally {
-      rmSync(noOrmDir, { recursive: true, force: true });
-    }
-  }, 60000);
-});