@milkio/template-milkio 1.3.63 → 1.3.66

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.63",
7
+ "version": "1.3.66",
8
8
  "keywords": [
9
9
  "template"
10
10
  ],
@@ -9,6 +9,11 @@ import type { generated } from '../../../.milkio/index.ts';
9
9
  // 这是样板代码,你可以按项目需要自由修改(换 pg/sqlite、加 SQL 日志、调连接数等)。
10
10
  const pools = new Map<string, mysql.Pool | mysql.Connection>();
11
11
 
12
+ // 测试模式下每个 cleanDatabase 都会切到一个全新的随机库,旧库连接不再使用。
13
+ // 连接只增不减会撞 MySQL max_connections(Too many connections),
14
+ // 因此给缓存的连接数加上限,超出时按插入顺序淘汰最旧的(LRU)。
15
+ const MAX_CACHED_CLIENTS = 32;
16
+
12
17
  export function loadDrizzle(world: MilkioWorld<typeof generated>) {
13
18
  world.on('milkio:executeBefore', async (event) => {
14
19
  const baseUrl = world.config.drizzle.url;
@@ -30,6 +35,16 @@ export function loadDrizzle(world: MilkioWorld<typeof generated>) {
30
35
  pool = mysql.createPool({ uri: url, connectionLimit: 8 });
31
36
  }
32
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
+ }
33
48
  }
34
49
 
35
50
  // 只挂 context.db(不挂全局 tx)。事务请在业务代码里用 db.transaction 显式管理。
@@ -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,7 +1,8 @@
1
1
  import { createAstra } from '@milkio/astra';
2
2
  import { createStargate } from '@milkio/stargate';
3
+ import { fileURLToPath } from 'node:url';
3
4
  import type { generated } from '../../.milkio/index.ts';
4
- import { drizzleCleanHook, dropAllTestDatabases } from './drizzle-test.ts';
5
+ import { drizzleCleanHook } from './drizzle-test.ts';
5
6
  import { redisCleanHook } from './redis-test.ts';
6
7
 
7
8
  export const stargate = await createStargate<typeof generated>({
@@ -11,15 +12,14 @@ export const stargate = await createStargate<typeof generated>({
11
12
  export const astra = await createAstra({
12
13
  stargate,
13
14
  bootstrap: async (hooks) => {
14
- // 每次运行测试前,先删掉上一次遗留的全部随机测试库。
15
- // 如果你的项目不使用数据库,可以删除下面这两行。
16
- await dropAllTestDatabases('mysql://root:a58423c29020@127.0.0.1:3306/');
17
-
18
15
  // 订阅 cleanDatabase 钩子:world.cleanDatabase() 每次都会新建一个随机库并切换,
19
- // 然后并行执行这里注册的所有 hook(建库+迁移+seed、清 redis 等)。
16
+ // 然后并行执行这里注册的所有 hook(建库+迁移+seed、清当前库 redis 命名空间等)。
17
+ // 上一次运行遗留的随机测试库在 vitest globalSetup 里统一删除
18
+ // (见 astra-global-setup.ts),不能在这里删——并行运行的其他测试文件正在使用它们。
19
+ // 如果你的项目不使用数据库,可以删除这些 hook。
20
20
  hooks.onCleanDatabase(drizzleCleanHook({
21
21
  baseUrl: () => 'mysql://root:a58423c29020@127.0.0.1:3306/',
22
- migrationsFolder: './drizzle',
22
+ migrationsFolder: fileURLToPath(new URL('../../drizzle', import.meta.url)),
23
23
  }));
24
24
  hooks.onCleanDatabase(redisCleanHook({ url: () => 'redis://127.0.0.1:6379/1' }));
25
25
 
@@ -1,14 +1,34 @@
1
1
  import { drizzle } from 'drizzle-orm/mysql2';
2
2
  import { migrate } from 'drizzle-orm/mysql2/migrator';
3
+ import type { MySql2Database } from 'drizzle-orm/mysql2';
3
4
  import mysql from 'mysql2/promise';
4
- import { sql } from 'drizzle-orm';
5
5
  import { TEST_DATABASE_PREFIX, withTestDatabase } from '@milkio/drizzle';
6
6
  import type { CleanDatabaseHook } from '@milkio/astra';
7
7
  import * as schema from '../../.milkio/drizzle-schema.ts';
8
8
  import { executeSeed } from '../../.milkio/seed.ts';
9
+ import { testDbState } from './test-state.ts';
9
10
 
10
- // 本文件是「测试数据库基建」样板代码:建库、完整迁移、seed、清库、删库都在这里,
11
+ // 本文件是「测试数据库基建」样板代码:建库、迁移、seed、清库、删库都在这里,
11
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;
12
32
 
13
33
  /** 建一个 admin 连接(不带库名),用于 CREATE / DROP DATABASE。 */
14
34
  async function createAdminConnection(baseUrl: string) {
@@ -31,31 +51,114 @@ export async function dropAllTestDatabases(baseUrl: string) {
31
51
  }
32
52
  }
33
53
 
34
- /** 创建数据库(IF NOT EXISTS)。 */
35
- export async function ensureDatabase(baseUrl: string, databaseId: string) {
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();
36
70
  const admin = await createAdminConnection(baseUrl);
37
71
  try {
38
- await admin.query(`CREATE DATABASE IF NOT EXISTS \`${databaseId}\``);
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}\``);
39
116
  } finally {
40
117
  await admin.end();
41
118
  }
42
119
  }
43
120
 
44
- /** 清空指定库中的所有业务表(跳过 drizzle 迁移表)。 */
45
- async function truncateAll(db: any) {
46
- const tables = (await db.execute(sql`SELECT table_name FROM information_schema.tables WHERE table_schema = DATABASE();`))[0] as unknown as Array<any>;
47
- await db.execute(sql`SET FOREIGN_KEY_CHECKS = 0;`);
48
- for (const table of tables) {
49
- if (!table.TABLE_NAME.startsWith('__drizzle_migrations')) {
50
- await db.execute(sql.raw(`TRUNCATE TABLE \`${table.TABLE_NAME}\`;`));
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}\``);
51
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();
52
136
  }
53
- await db.execute(sql`SET FOREIGN_KEY_CHECKS = 1;`);
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);
54
143
  }
55
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
+
56
158
  /**
57
159
  * astra 的 cleanDatabase 钩子:每次显式调用 world.cleanDatabase() 都会
58
- * 生成一个全新随机库并切换到这里。该钩子负责建库、完整迁移、seed。
160
+ * 生成一个全新随机库并切换到这里。该钩子负责从黄金库克隆 DDL + seed,
161
+ * 并把当前库状态写入 testDbState 供测试文件直连。
59
162
  * 这是样板实现,你可以按需修改(换方言、跳过 seed、控制迁移目录等)。
60
163
  */
61
164
  export function drizzleCleanHook(options: {
@@ -63,18 +166,33 @@ export function drizzleCleanHook(options: {
63
166
  migrationsFolder: string;
64
167
  }): CleanDatabaseHook {
65
168
  return async ({ databaseId }) => {
66
- const baseUrl = await options.baseUrl();
67
- await ensureDatabase(baseUrl, databaseId);
169
+ const baseUrl = (await options.baseUrl()).replace(/\/$/, '');
170
+ await ensureGoldenDatabase({ baseUrl, migrationsFolder: options.migrationsFolder });
171
+ await cloneGoldenDatabase(baseUrl, databaseId);
68
172
 
69
173
  const url = withTestDatabase(baseUrl, databaseId);
70
174
  const connection = await mysql.createConnection({ uri: url, timezone: '+00:00' });
71
175
  await connection.query("SET time_zone = '+00:00'");
72
176
  const db = drizzle(connection, { schema, mode: 'default' });
73
177
 
74
- await migrate(db, { migrationsFolder: options.migrationsFolder });
75
- await truncateAll(db);
76
178
  await db.transaction(async (tx) => executeSeed({ db: tx }));
77
179
 
78
- await connection.end();
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
+ }
79
197
  };
80
198
  }
@@ -1,17 +1,45 @@
1
1
  import { createClient } from 'redis';
2
2
  import type { CleanDatabaseHook } from '@milkio/astra';
3
+ import { testDbState } from './test-state.ts';
3
4
 
4
5
  /**
5
- * astra 的 cleanDatabase 钩子(Redis):清空缓存。
6
- * 这是样板实现,你可以按需修改(例如只删指定前缀的 key,而不是 flushDb)。
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
+ * 这是样板实现,你可以按需修改。
7
29
  */
8
30
  export function redisCleanHook(options: { url: () => string | Promise<string> }): CleanDatabaseHook {
9
- return async () => {
31
+ return async ({ databaseId }) => {
32
+ testDbState.databaseId = databaseId;
10
33
  const url = await options.url();
11
34
  const client = createClient({ url });
12
35
  client.on('error', (err) => console.error('Redis Client Error', err));
13
36
  await client.connect();
14
- await client.flushDb();
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');
15
43
  await client.close();
16
44
  };
17
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
+ };
@@ -9,10 +9,10 @@
9
9
  },
10
10
  "trustedDependencies": [],
11
11
  "dependencies": {
12
- "@milkio/astra": "1.3.63",
13
- "@milkio/drizzle": "1.3.63",
14
- "@milkio/redis": "1.3.63",
15
- "@milkio/stargate": "1.3.63",
12
+ "@milkio/astra": "1.3.66",
13
+ "@milkio/drizzle": "1.3.66",
14
+ "@milkio/redis": "1.3.66",
15
+ "@milkio/stargate": "1.3.66",
16
16
  "drizzle-orm": "^0.43.1",
17
17
  "mysql2": "^3.11.0",
18
18
  "redis": "^4.7.0"
@@ -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
  },