@milkio/template-milkio 1.3.61 → 1.3.65

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/package.json CHANGED
@@ -4,7 +4,7 @@
4
4
  "type": "git",
5
5
  "url": "https://github.com/akirarika/milkio"
6
6
  },
7
- "version": "1.3.61",
7
+ "version": "1.3.65",
8
8
  "keywords": [
9
9
  "template"
10
10
  ],
@@ -0,0 +1,53 @@
1
+ import mysql from 'mysql2/promise';
2
+ import { drizzle } from 'drizzle-orm/mysql2';
3
+ import { getTestDatabaseId, withTestDatabase } from '@milkio/drizzle';
4
+ import * as schema from '../../../.milkio/drizzle-schema.ts';
5
+ import type { MilkioWorld } from 'milkio';
6
+ import type { generated } from '../../../.milkio/index.ts';
7
+
8
+ // 数据库连接池按「连接 URL」懒建,测试环境下每个随机库一个连接。
9
+ // 这是样板代码,你可以按项目需要自由修改(换 pg/sqlite、加 SQL 日志、调连接数等)。
10
+ const pools = new Map<string, mysql.Pool | mysql.Connection>();
11
+
12
+ // 测试模式下每个 cleanDatabase 都会切到一个全新的随机库,旧库连接不再使用。
13
+ // 连接只增不减会撞 MySQL max_connections(Too many connections),
14
+ // 因此给缓存的连接数加上限,超出时按插入顺序淘汰最旧的(LRU)。
15
+ const MAX_CACHED_CLIENTS = 32;
16
+
17
+ export function loadDrizzle(world: MilkioWorld<typeof generated>) {
18
+ world.on('milkio:executeBefore', async (event) => {
19
+ const baseUrl = world.config.drizzle.url;
20
+
21
+ // 测试模式下,astra 会携带 x-milkio-test-db 请求头指明本次请求的随机数据库;
22
+ // 没有携带时(本地网页调试 / 生产环境)走默认库,行为与旧版完全一致。
23
+ const databaseId = getTestDatabaseId(event.context.headers);
24
+ const url = withTestDatabase(baseUrl, databaseId);
25
+
26
+ let pool = pools.get(url);
27
+ if (!pool) {
28
+ if (world.isTestMode) {
29
+ // 本地 test 库会话时区非 UTC:用单连接并显式固定 UTC+0,
30
+ // 保证 seed 写入的墙钟与读取口径统一。
31
+ const connection = await mysql.createConnection({ uri: url, timezone: '+00:00' });
32
+ await connection.query("SET time_zone = '+00:00'");
33
+ pool = connection;
34
+ } else {
35
+ pool = mysql.createPool({ uri: url, connectionLimit: 8 });
36
+ }
37
+ pools.set(url, pool);
38
+
39
+ while (pools.size > MAX_CACHED_CLIENTS) {
40
+ const oldestKey = pools.keys().next().value as string;
41
+ if (oldestKey === url) break;
42
+ const oldest = pools.get(oldestKey);
43
+ pools.delete(oldestKey);
44
+ // 不能 await:被淘汰的连接可能仍有请求在途(例如测试超时后请求还在服务端跑),
45
+ // await end() 会一直等到它空闲,导致当前请求被挂起
46
+ void oldest?.end?.().catch(() => {});
47
+ }
48
+ }
49
+
50
+ // 只挂 context.db(不挂全局 tx)。事务请在业务代码里用 db.transaction 显式管理。
51
+ event.context.db = drizzle(pool, { schema, mode: 'default' });
52
+ });
53
+ }
@@ -0,0 +1,9 @@
1
+ import type { MySql2Database } from 'drizzle-orm/mysql2';
2
+ import type * as schema from '../../.milkio/drizzle-schema.ts';
3
+
4
+ // 项目自定义的 context 挂载点。这里只挂 db,不挂全局 tx:
5
+ // 事务应通过 `context.db.transaction(async (tx) => { ... })` 由调用方显式传递 tx 对象。
6
+ // 如需切换到 pg / sqlite,请把类型换成对应的 drizzle 数据库类型并安装相应驱动。
7
+ export interface _ {
8
+ db: MySql2Database<typeof schema>;
9
+ }
@@ -3,6 +3,11 @@ import { astra } from '../utils/astra.ts';
3
3
 
4
4
  test('basic', async () => {
5
5
  const [context, reject, world] = await astra.createMirrorWorld(import.meta.url);
6
+
7
+ // 每次显式调用都会新建一个随机测试库、完整迁移并 seed,然后切换过去。
8
+ // 如果你的项目不使用数据库,可以删除这一行。
9
+ await world.cleanDatabase();
10
+
6
11
  const [error, result] = await world.execute('/', {
7
12
  generateParams: true,
8
13
  });
@@ -0,0 +1,24 @@
1
+ import { relations, sql } from 'drizzle-orm';
2
+ import { char, datetime, mysqlTable, varchar } from 'drizzle-orm/mysql-core';
3
+
4
+ // 示例表:可按需修改或删除。
5
+ const tableName = 'user';
6
+
7
+ export const userTable = mysqlTable(
8
+ tableName,
9
+ {
10
+ // 主键 ID,24 位随机字符串
11
+ id: char({ length: 24 }).notNull().primaryKey(),
12
+ // 名称
13
+ name: varchar({ length: 32 }).notNull(),
14
+ // 创建时间
15
+ createdAt: datetime({ fsp: 3 }).notNull().default(sql`CURRENT_TIMESTAMP(3)`),
16
+ // 更新时间
17
+ updatedAt: datetime({ fsp: 3 }).notNull().default(sql`CURRENT_TIMESTAMP(3) ON UPDATE CURRENT_TIMESTAMP(3)`),
18
+ },
19
+ () => [],
20
+ );
21
+
22
+ export const userRelations = relations(userTable, () => ({}));
23
+
24
+ export type User = typeof userTable.$inferSelect;
@@ -0,0 +1,25 @@
1
+ // vitest globalSetup:每次测试运行只执行一次(在 vitest.config.ts 注册)。
2
+ // setup 阶段:清掉上一次运行遗留的随机测试库与缓存,并准备好「黄金库」——
3
+ // 完整迁移只在这里跑一次,之后每个测试库直接从黄金库克隆 DDL。
4
+ // teardown 阶段(测试全部结束后):清理本次创建的随机测试库与黄金库,保持磁盘健康。
5
+ // 不能放在每个测试文件的 astra bootstrap 里做——并行运行时,后启动的文件会把
6
+ // 先启动文件正在使用的随机库删掉。
7
+ import { fileURLToPath } from 'node:url';
8
+ import { dropAllTestDatabases, dropGoldenDatabase, ensureGoldenDatabase } from './drizzle-test.ts';
9
+ import { flushTestRedis } from './redis-test.ts';
10
+
11
+ export default async function setup() {
12
+ const baseUrl = 'mysql://root:a58423c29020@127.0.0.1:3306/kecream_server';
13
+ await dropAllTestDatabases(baseUrl);
14
+ await flushTestRedis('redis://127.0.0.1:6379/1');
15
+ await ensureGoldenDatabase({
16
+ baseUrl,
17
+ migrationsFolder: fileURLToPath(new URL('../../drizzle', import.meta.url)),
18
+ force: true,
19
+ });
20
+
21
+ return async () => {
22
+ await dropAllTestDatabases(baseUrl);
23
+ await dropGoldenDatabase(baseUrl);
24
+ };
25
+ }
@@ -1,14 +1,28 @@
1
- import { createAstra } from "@milkio/astra";
2
- import { createStargate } from "@milkio/stargate";
3
- import type { generated } from "../../.milkio/index.ts";
1
+ import { createAstra } from '@milkio/astra';
2
+ import { createStargate } from '@milkio/stargate';
3
+ import { fileURLToPath } from 'node:url';
4
+ import type { generated } from '../../.milkio/index.ts';
5
+ import { drizzleCleanHook } from './drizzle-test.ts';
6
+ import { redisCleanHook } from './redis-test.ts';
4
7
 
5
8
  export const stargate = await createStargate<typeof generated>({
6
- baseUrl: "http://localhost:9000",
9
+ baseUrl: 'http://localhost:9000',
7
10
  });
8
11
 
9
12
  export const astra = await createAstra({
10
- stargate,
11
- bootstrap: async () => {
12
- return {}
13
- },
13
+ stargate,
14
+ bootstrap: async (hooks) => {
15
+ // 订阅 cleanDatabase 钩子:world.cleanDatabase() 每次都会新建一个随机库并切换,
16
+ // 然后并行执行这里注册的所有 hook(建库+迁移+seed、清当前库 redis 命名空间等)。
17
+ // 上一次运行遗留的随机测试库在 vitest globalSetup 里统一删除
18
+ // (见 astra-global-setup.ts),不能在这里删——并行运行的其他测试文件正在使用它们。
19
+ // 如果你的项目不使用数据库,可以删除这些 hook。
20
+ hooks.onCleanDatabase(drizzleCleanHook({
21
+ baseUrl: () => 'mysql://root:a58423c29020@127.0.0.1:3306/',
22
+ migrationsFolder: fileURLToPath(new URL('../../drizzle', import.meta.url)),
23
+ }));
24
+ hooks.onCleanDatabase(redisCleanHook({ url: () => 'redis://127.0.0.1:6379/1' }));
25
+
26
+ return {};
27
+ },
14
28
  });
@@ -0,0 +1,198 @@
1
+ import { drizzle } from 'drizzle-orm/mysql2';
2
+ import { migrate } from 'drizzle-orm/mysql2/migrator';
3
+ import type { MySql2Database } from 'drizzle-orm/mysql2';
4
+ import mysql from 'mysql2/promise';
5
+ import { TEST_DATABASE_PREFIX, withTestDatabase } from '@milkio/drizzle';
6
+ import type { CleanDatabaseHook } from '@milkio/astra';
7
+ import * as schema from '../../.milkio/drizzle-schema.ts';
8
+ import { executeSeed } from '../../.milkio/seed.ts';
9
+ import { testDbState } from './test-state.ts';
10
+
11
+ // 本文件是「测试数据库基建」样板代码:建库、迁移、seed、清库、删库都在这里,
12
+ // 全部由你掌控,可按项目实际方言(mysql/pg/sqlite)自由修改。
13
+ //
14
+ // 「黄金库」方案:完整迁移(几十个迁移文件)只需要跑一次,放在 vitest
15
+ // globalSetup 里执行;之后每个 cleanDatabase 直接克隆黄金库的 DDL
16
+ // (CREATE TABLE ... LIKE)+ seed,几秒内即可准备好一个全新随机测试库。
17
+ // 如果单次迁移足够快,也可以改回每次 cleanDatabase 都完整迁移。
18
+
19
+ /** 黄金库名:完整迁移只跑一次,所有测试库都从它克隆。 */
20
+ export const GOLDEN_DATABASE_NAME = 'milkio_golden';
21
+
22
+ const GOLDEN_LOCK_NAME = 'milkio_golden_migration';
23
+
24
+ let goldenPromise: Promise<void> | null = null;
25
+
26
+ // drizzleCleanHook 自己维护「上一个测试库」,不依赖 testDbState:
27
+ // redisCleanHook 与 drizzleCleanHook 并行执行,且 redis 钩子也会写
28
+ // testDbState.databaseId(新值),并行时序下从 testDbState 读到的
29
+ // "上一个" 实际上是当前值,会导致旧库永远不会被删除。
30
+ let lastDatabaseId: string | null = null;
31
+ let lastConnection: { end: () => Promise<void> } | null = null;
32
+
33
+ /** 建一个 admin 连接(不带库名),用于 CREATE / DROP DATABASE。 */
34
+ async function createAdminConnection(baseUrl: string) {
35
+ const url = new URL(baseUrl);
36
+ url.pathname = '/';
37
+ return mysql.createConnection({ uri: url.toString() });
38
+ }
39
+
40
+ /** 删除上一次测试遗留的所有随机测试库。 */
41
+ export async function dropAllTestDatabases(baseUrl: string) {
42
+ const admin = await createAdminConnection(baseUrl);
43
+ try {
44
+ const [rows] = await admin.query(`SHOW DATABASES LIKE '${TEST_DATABASE_PREFIX}_%'`);
45
+ for (const row of rows as Array<Record<string, string>>) {
46
+ const name = Object.values(row)[0];
47
+ await admin.query(`DROP DATABASE IF EXISTS \`${name}\``);
48
+ }
49
+ } finally {
50
+ await admin.end();
51
+ }
52
+ }
53
+
54
+ /**
55
+ * 确保黄金库存在且已完成完整迁移。幂等:
56
+ * - 进程内用模块级 promise 缓存,只会真正执行一次;
57
+ * - 跨进程(vitest 多 worker)用 MySQL GET_LOCK 串行化;
58
+ * - force=true 时先删后建(globalSetup 每次运行调用,保证 schema 最新)。
59
+ */
60
+ export function ensureGoldenDatabase(options: { baseUrl: string; migrationsFolder: string; force?: boolean }): Promise<void> {
61
+ if (!options.force && goldenPromise) return goldenPromise;
62
+ goldenPromise = ensureGoldenDatabaseInner(options);
63
+ return goldenPromise;
64
+ }
65
+
66
+ async function ensureGoldenDatabaseInner({ baseUrl, migrationsFolder, force }: { baseUrl: string; migrationsFolder: string; force?: boolean }) {
67
+ const goldenUrlObject = new URL(baseUrl);
68
+ goldenUrlObject.pathname = `/${GOLDEN_DATABASE_NAME}`;
69
+ const goldenUrl = goldenUrlObject.toString();
70
+ const admin = await createAdminConnection(baseUrl);
71
+ try {
72
+ await admin.query(`SELECT GET_LOCK('${GOLDEN_LOCK_NAME}', 600)`);
73
+ try {
74
+ if (force) {
75
+ await admin.query(`DROP DATABASE IF EXISTS \`${GOLDEN_DATABASE_NAME}\``);
76
+ await admin.query(`CREATE DATABASE \`${GOLDEN_DATABASE_NAME}\``);
77
+ } else {
78
+ const [dbs] = await admin.query(`SHOW DATABASES LIKE '${GOLDEN_DATABASE_NAME}'`);
79
+ const exists = (dbs as Array<any>).length > 0;
80
+ if (exists) {
81
+ const [tables] = await admin.query(
82
+ `SELECT COUNT(*) AS c FROM information_schema.tables WHERE table_schema = '${GOLDEN_DATABASE_NAME}' AND table_name = '__drizzle_migrations'`,
83
+ );
84
+ if (Number((tables as Array<any>)[0].c) > 0) return;
85
+ }
86
+ await admin.query(`CREATE DATABASE IF NOT EXISTS \`${GOLDEN_DATABASE_NAME}\``);
87
+ }
88
+ const connection = await mysql.createConnection({ uri: goldenUrl, timezone: '+00:00' });
89
+ await connection.query("SET time_zone = '+00:00'");
90
+ const db = drizzle(connection, { schema, mode: 'default' });
91
+ await migrate(db, { migrationsFolder });
92
+ await connection.end();
93
+ } finally {
94
+ await admin.query(`SELECT RELEASE_LOCK('${GOLDEN_LOCK_NAME}')`);
95
+ }
96
+ } finally {
97
+ await admin.end();
98
+ }
99
+ }
100
+
101
+ /** 删除单个测试库。 */
102
+ export async function dropDatabase(baseUrl: string, databaseId: string) {
103
+ const admin = await createAdminConnection(baseUrl);
104
+ try {
105
+ await admin.query(`DROP DATABASE IF EXISTS \`${databaseId}\``);
106
+ } finally {
107
+ await admin.end();
108
+ }
109
+ }
110
+
111
+ /** 删除黄金库。 */
112
+ export async function dropGoldenDatabase(baseUrl: string) {
113
+ const admin = await createAdminConnection(baseUrl);
114
+ try {
115
+ await admin.query(`DROP DATABASE IF EXISTS \`${GOLDEN_DATABASE_NAME}\``);
116
+ } finally {
117
+ await admin.end();
118
+ }
119
+ }
120
+
121
+ /** 从黄金库克隆 DDL 到新的随机测试库(不复制数据)。 */
122
+ export async function cloneGoldenDatabase(baseUrl: string, databaseId: string) {
123
+ const admin = await createAdminConnection(baseUrl);
124
+ try {
125
+ await admin.query(`CREATE DATABASE IF NOT EXISTS \`${databaseId}\``);
126
+ const [rows] = await admin.query(`SELECT table_name FROM information_schema.tables WHERE table_schema = '${GOLDEN_DATABASE_NAME}'`);
127
+ for (const row of rows as Array<Record<string, string>>) {
128
+ const table = Object.values(row)[0];
129
+ await admin.query(`CREATE TABLE \`${databaseId}\`.\`${table}\` LIKE \`${GOLDEN_DATABASE_NAME}\`.\`${table}\``);
130
+ }
131
+ await admin.query(
132
+ `INSERT INTO \`${databaseId}\`.\`__drizzle_migrations\` SELECT * FROM \`${GOLDEN_DATABASE_NAME}\`.\`__drizzle_migrations\``,
133
+ );
134
+ } finally {
135
+ await admin.end();
136
+ }
137
+ }
138
+
139
+ /** 当前随机测试库的完整连接 URL(cleanDatabase 之后可用)。 */
140
+ export function getCurrentTestDbUrl(baseUrl: string): string {
141
+ if (!testDbState.databaseId) throw new Error('No active test database. Call world.cleanDatabase() first.');
142
+ return withTestDatabase(baseUrl, testDbState.databaseId);
143
+ }
144
+
145
+ /**
146
+ * 跟随当前随机测试库的直连 db。cleanDatabase 每次切库都会重建底层连接,
147
+ * 测试文件直接 import 这个 db 使用即可,无需关心当前库名。
148
+ */
149
+ export const db = new Proxy({} as Record<PropertyKey, unknown>, {
150
+ get: (_, prop) => {
151
+ const target = testDbState.db;
152
+ if (!target) throw new Error('No active test database. Call world.cleanDatabase() before using db.');
153
+ const value = Reflect.get(target, prop);
154
+ return typeof value === 'function' ? value.bind(target) : value;
155
+ },
156
+ }) as unknown as MySql2Database<typeof schema>;
157
+
158
+ /**
159
+ * astra 的 cleanDatabase 钩子:每次显式调用 world.cleanDatabase() 都会
160
+ * 生成一个全新随机库并切换到这里。该钩子负责从黄金库克隆 DDL + seed,
161
+ * 并把当前库状态写入 testDbState 供测试文件直连。
162
+ * 这是样板实现,你可以按需修改(换方言、跳过 seed、控制迁移目录等)。
163
+ */
164
+ export function drizzleCleanHook(options: {
165
+ baseUrl: () => string | Promise<string>;
166
+ migrationsFolder: string;
167
+ }): CleanDatabaseHook {
168
+ return async ({ databaseId }) => {
169
+ const baseUrl = (await options.baseUrl()).replace(/\/$/, '');
170
+ await ensureGoldenDatabase({ baseUrl, migrationsFolder: options.migrationsFolder });
171
+ await cloneGoldenDatabase(baseUrl, databaseId);
172
+
173
+ const url = withTestDatabase(baseUrl, databaseId);
174
+ const connection = await mysql.createConnection({ uri: url, timezone: '+00:00' });
175
+ await connection.query("SET time_zone = '+00:00'");
176
+ const db = drizzle(connection, { schema, mode: 'default' });
177
+
178
+ await db.transaction(async (tx) => executeSeed({ db: tx }));
179
+
180
+ // 切换到新库:关闭上一个测试库的连接并删除该库。
181
+ // 分区表克隆每库可达 100MB+,只增不减会撑爆磁盘;切库即删让同时存在的
182
+ // 测试库数量 = 并行测试文件数(个位数),磁盘占用保持个位数 GB 以内。
183
+ const previousDatabaseId = lastDatabaseId;
184
+ const previousConnection = lastConnection;
185
+ lastDatabaseId = databaseId;
186
+ lastConnection = connection;
187
+ testDbState.databaseId = databaseId;
188
+ testDbState.db = db;
189
+ testDbState.connection = connection;
190
+ if (previousConnection) await previousConnection.end().catch(() => {});
191
+ if (previousDatabaseId && previousDatabaseId !== databaseId) {
192
+ // drop 不阻塞 cleanDatabase:并发的 DROP DATABASE 与 CREATE TABLE LIKE 会抢
193
+ // MySQL 元数据锁(MDL),并行多个测试文件时 DDL 被串行化,单次 cleanDatabase 可被
194
+ // 拖到超时。drop 改为后台执行,由 globalSetup teardown 兜底清理残留库。
195
+ void dropDatabase(baseUrl, previousDatabaseId).catch(() => {});
196
+ }
197
+ };
198
+ }
@@ -0,0 +1,45 @@
1
+ import { createClient } from 'redis';
2
+ import type { CleanDatabaseHook } from '@milkio/astra';
3
+ import { testDbState } from './test-state.ts';
4
+
5
+ /**
6
+ * 当前随机测试库的 redis key 前缀。服务端在测试模式下应把所有业务 key
7
+ * 加上 `${databaseId}:` 前缀(参考 kecream-server 的 bootstrap/redis 与 my-redis 样板),
8
+ * 测试文件里直连 redis 操作业务 key 时也要经过这个函数。
9
+ */
10
+ export function testRedisKey(key: string): string {
11
+ if (!testDbState.databaseId) throw new Error('No active test database. Call world.cleanDatabase() first.');
12
+ return `${testDbState.databaseId}:${key}`;
13
+ }
14
+
15
+ /** 清空整个 redis db:仅在每次测试运行的 globalSetup 里调用一次。 */
16
+ export async function flushTestRedis(url: string) {
17
+ const client = createClient({ url });
18
+ client.on('error', (err) => console.error('Redis Client Error', err));
19
+ await client.connect();
20
+ await client.flushDb();
21
+ await client.close();
22
+ }
23
+
24
+ /**
25
+ * astra 的 cleanDatabase 钩子(Redis):清理当前测试库命名空间下的缓存。
26
+ * 不同测试文件共用同一个 redis 但 key 前缀不同,互不干扰,
27
+ * 因此这里只按前缀清理,绝不能 flushDb(会误删并行中其他测试文件的数据)。
28
+ * 这是样板实现,你可以按需修改。
29
+ */
30
+ export function redisCleanHook(options: { url: () => string | Promise<string> }): CleanDatabaseHook {
31
+ return async ({ databaseId }) => {
32
+ testDbState.databaseId = databaseId;
33
+ const url = await options.url();
34
+ const client = createClient({ url });
35
+ client.on('error', (err) => console.error('Redis Client Error', err));
36
+ await client.connect();
37
+ let cursor = '0';
38
+ do {
39
+ const reply = await client.scan(cursor, { MATCH: `${databaseId}:*`, COUNT: 1000 });
40
+ cursor = String(reply.cursor);
41
+ if (reply.keys.length > 0) await client.del(reply.keys);
42
+ } while (cursor !== '0');
43
+ await client.close();
44
+ };
45
+ }
@@ -0,0 +1,13 @@
1
+ // 当前测试文件进程内「正在使用的随机测试库」状态。
2
+ // world.cleanDatabase() 每次都会新建一个随机库并切换,drizzle/redis 的
3
+ // cleanDatabase 钩子会把最新状态写到这里;测试文件里的直连 db/redis
4
+ // 辅助(db、testRedisKey、getCurrentTestDbUrl)都从这里读取当前库。
5
+ export const testDbState: {
6
+ databaseId: string | null;
7
+ db: any | null;
8
+ connection: { end: () => Promise<void> } | null;
9
+ } = {
10
+ databaseId: null,
11
+ db: null,
12
+ connection: null,
13
+ };
package/template/index.ts CHANGED
@@ -1,11 +1,12 @@
1
1
  import { createWorld, type MilkioInit } from "milkio";
2
2
  import { configSchema } from "./.milkio/config-schema.ts";
3
3
  import { generated } from "./.milkio/index.ts";
4
+ import { loadDrizzle } from "./app/bootstrap/drizzle/index.ts";
4
5
 
5
6
  export async function create(options: MilkioInit) {
6
7
  const world = await createWorld(generated, configSchema, {
7
8
  ...options,
8
- bootstraps: [],
9
+ bootstraps: [loadDrizzle],
9
10
  });
10
11
 
11
12
  return world;
@@ -8,6 +8,14 @@
8
8
  "build": "vite build"
9
9
  },
10
10
  "trustedDependencies": [],
11
- "dependencies": {},
11
+ "dependencies": {
12
+ "@milkio/astra": "1.3.65",
13
+ "@milkio/drizzle": "1.3.65",
14
+ "@milkio/redis": "1.3.65",
15
+ "@milkio/stargate": "1.3.65",
16
+ "drizzle-orm": "^0.43.1",
17
+ "mysql2": "^3.11.0",
18
+ "redis": "^4.7.0"
19
+ },
12
20
  "devDependencies": {}
13
21
  }
@@ -2,8 +2,11 @@ import { defineProject } from 'vitest/config';
2
2
 
3
3
  export default defineProject({
4
4
  test: {
5
- testTimeout: 60000,
6
- fileParallelism: false,
5
+ testTimeout: 180000,
6
+ // 每次运行只执行一次:删除上一次遗留的随机测试库、清空缓存
7
+ globalSetup: ['./app/utils/astra-global-setup.ts'],
8
+ // 测试使用独立的随机测试库(每次 cleanDatabase 都会新建并切换),
9
+ // 不同测试文件之间互不干扰,因此可以放开并行限制
7
10
  sequence: {
8
11
  concurrent: false,
9
12
  },