create-windy 0.2.33 → 0.3.0

package/template/apps/server/src/configuration/definition.ts

@@ -1,4 +1,7 @@
-import { platformConfigDefinition, type PlatformConfig } from "@southwind-ai/config";
+import {
+  platformConfigDefinition,
+  type PlatformConfig,
+} from "@southwind-ai/config";
 import type {
   ModuleConfigFieldDescriptor,
   ModuleConfigValues,
@@ -18,21 +21,68 @@ export interface PlatformConfigApplyListener {
   applied(config: PlatformConfig): void;
 }
 
-const managedPaths = ["enableAI", "cache.healthTimeoutMs"] as const;
-const platformValuesSchema = z.strictObject({
-  enableAI: z.boolean(),
-  "cache.healthTimeoutMs": z.number().int().min(50).max(10_000),
-});
+const managedPaths = [
+  "enableAI",
+  "cache.healthTimeoutMs",
+  "security.sessionTtlSeconds",
+  "security.passwordMinLength",
+  "security.passwordMaxLength",
+  "storage.bulkDataMaxByteSize",
+  "storage.brandingLogoMaxByteSize",
+  "mail.enabled",
+  "mail.host",
+  "mail.port",
+  "mail.secure",
+  "mail.fromAddress",
+  "mail.connectTimeoutMs",
+  "regional.timeZone",
+] as const;
+const platformValuesSchema = z
+  .strictObject({
+    enableAI: z.boolean(),
+    "cache.healthTimeoutMs": z.number().int().min(50).max(10_000),
+    "security.sessionTtlSeconds": z.number().int().min(60).max(2_592_000),
+    "security.passwordMinLength": z.number().int().min(8).max(128),
+    "security.passwordMaxLength": z.number().int().min(12).max(512),
+    "storage.bulkDataMaxByteSize": z
+      .number()
+      .int()
+      .min(1024)
+      .max(10 * 1024 ** 3),
+    "storage.brandingLogoMaxByteSize": z
+      .number()
+      .int()
+      .min(1024)
+      .max(50 * 1024 ** 2),
+    "mail.enabled": z.boolean(),
+    "mail.host": z.string().trim().max(253),
+    "mail.port": z.number().int().min(1).max(65_535),
+    "mail.secure": z.boolean(),
+    "mail.fromAddress": z.string().trim().max(320),
+    "mail.connectTimeoutMs": z.number().int().min(100).max(120_000),
+    "regional.timeZone": z
+      .string()
+      .trim()
+      .min(1)
+      .max(100)
+      .refine(isSupportedTimeZone),
+  })
+  .refine(
+    (values) =>
+      values["security.passwordMinLength"] <=
+      values["security.passwordMaxLength"],
+    { message: "密码最小长度不能大于最大长度" },
+  );
 
 export class PlatformConfigApplyAdapter {
-  private listener?: PlatformConfigApplyListener;
+  private readonly listeners = new Set<PlatformConfigApplyListener>();
 
   constructor(private readonly config: PlatformConfig) {
     assertSafeManagedPaths();
   }
 
-  setListener(listener: PlatformConfigApplyListener): void {
-    this.listener = listener;
+  addListener(listener: PlatformConfigApplyListener): void {
+    this.listeners.add(listener);
   }
 
   definition(): ManagedModuleConfigDefinition {
@@ -45,6 +95,7 @@ export class PlatformConfigApplyAdapter {
           label: "AI 能力总开关",
           description: "控制 foundation 快照中的平台 AI 能力声明。",
           input: "boolean",
+          applyMode: "live",
         },
         {
           path: "cache.healthTimeoutMs",
@@ -53,29 +104,208 @@ export class PlatformConfigApplyAdapter {
           input: "integer",
           minimum: 50,
           maximum: 10_000,
+          applyMode: "live",
+        },
+        integerField(
+          "security.sessionTtlSeconds",
+          "会话有效期",
+          "控制新创建会话的有效期，单位为秒；已存在会话保持原过期时间。",
+          60,
+          2_592_000,
+        ),
+        integerField(
+          "security.passwordMinLength",
+          "密码最小长度",
+          "修改或重置密码时立即使用的新最小长度。",
+          8,
+          128,
+        ),
+        integerField(
+          "security.passwordMaxLength",
+          "密码最大长度",
+          "修改或重置密码时立即使用的新最大长度。",
+          12,
+          512,
+        ),
+        integerField(
+          "storage.bulkDataMaxByteSize",
+          "批量数据文件上限",
+          "批量导入导出上传的最大字节数。",
+          1024,
+          10 * 1024 ** 3,
+        ),
+        integerField(
+          "storage.brandingLogoMaxByteSize",
+          "品牌 Logo 文件上限",
+          "品牌 Logo 上传的最大字节数。",
+          1024,
+          50 * 1024 ** 2,
+        ),
+        restartBooleanField(
+          "mail.enabled",
+          "启用邮件传输配置",
+          "控制邮件传输配置是否启用；仍需安装业务邮件发送 Adapter。",
+        ),
+        restartTextField("mail.host", "SMTP 主机", "SMTP 服务主机名。"),
+        restartIntegerField(
+          "mail.port",
+          "SMTP 端口",
+          "SMTP 服务端口。",
+          1,
+          65_535,
+        ),
+        restartBooleanField(
+          "mail.secure",
+          "SMTP TLS 直连",
+          "启用后使用 TLS 直连；STARTTLS 由后续邮件 Adapter 处理。",
+        ),
+        restartTextField(
+          "mail.fromAddress",
+          "默认发件地址",
+          "邮件 Adapter 使用的默认 From 地址。",
+        ),
+        restartIntegerField(
+          "mail.connectTimeoutMs",
+          "SMTP 连接超时",
+          "邮件 Adapter 建立连接的超时时间，单位为毫秒。",
+          100,
+          120_000,
+        ),
+        {
+          path: "regional.timeZone",
+          label: "显示时区",
+          description: "平台日期时间展示使用的 IANA 时区，例如 Asia/Shanghai。",
+          input: "text",
+          applyMode: "live",
         },
       ],
-      validate: (values) => platformValuesSchema.parse(values),
+      validate: (values) =>
+        this.parse({
+          ...this.values(),
+          ...(isRecord(values) ? values : {}),
+        }),
       apply: (values) => this.apply(values),
       baseValues: () => this.values(),
     };
   }
 
   private apply(values: ModuleConfigValues): void {
-    const parsed = platformValuesSchema.parse(values);
+    const parsed = this.parse(values);
     this.config.enableAI = parsed.enableAI;
     this.config.cache.healthTimeoutMs = parsed["cache.healthTimeoutMs"];
-    this.listener?.applied(this.config);
+    this.config.security.sessionTtlSeconds =
+      parsed["security.sessionTtlSeconds"];
+    this.config.security.passwordMinLength =
+      parsed["security.passwordMinLength"];
+    this.config.security.passwordMaxLength =
+      parsed["security.passwordMaxLength"];
+    this.config.storage.bulkDataMaxByteSize =
+      parsed["storage.bulkDataMaxByteSize"];
+    this.config.storage.brandingLogoMaxByteSize =
+      parsed["storage.brandingLogoMaxByteSize"];
+    this.config.mail.enabled = parsed["mail.enabled"];
+    this.config.mail.host = parsed["mail.host"];
+    this.config.mail.port = parsed["mail.port"];
+    this.config.mail.secure = parsed["mail.secure"];
+    this.config.mail.fromAddress = parsed["mail.fromAddress"];
+    this.config.mail.connectTimeoutMs = parsed["mail.connectTimeoutMs"];
+    this.config.regional.timeZone = parsed["regional.timeZone"];
+    for (const listener of this.listeners) listener.applied(this.config);
+  }
+
+  private parse(values: unknown) {
+    const parsed = platformValuesSchema.parse(values);
+    if (
+      parsed["mail.enabled"] &&
+      (!parsed["mail.fromAddress"] ||
+        (!parsed["mail.host"] && !this.config.mail.smtpUrl))
+    ) {
+      throw new Error("邮件传输配置不完整");
+    }
+    return parsed;
   }
 
   private values(): ModuleConfigValues {
     return {
       enableAI: this.config.enableAI,
       "cache.healthTimeoutMs": this.config.cache.healthTimeoutMs,
+      "security.sessionTtlSeconds": this.config.security.sessionTtlSeconds,
+      "security.passwordMinLength": this.config.security.passwordMinLength,
+      "security.passwordMaxLength": this.config.security.passwordMaxLength,
+      "storage.bulkDataMaxByteSize": this.config.storage.bulkDataMaxByteSize,
+      "storage.brandingLogoMaxByteSize":
+        this.config.storage.brandingLogoMaxByteSize,
+      "mail.enabled": this.config.mail.enabled,
+      "mail.host": this.config.mail.host,
+      "mail.port": this.config.mail.port,
+      "mail.secure": this.config.mail.secure,
+      "mail.fromAddress": this.config.mail.fromAddress,
+      "mail.connectTimeoutMs": this.config.mail.connectTimeoutMs,
+      "regional.timeZone": this.config.regional.timeZone,
     };
   }
 }
 
+function integerField(
+  path: string,
+  label: string,
+  description: string,
+  minimum: number,
+  maximum: number,
+): ModuleConfigFieldDescriptor {
+  return {
+    path,
+    label,
+    description,
+    input: "integer",
+    applyMode: "live",
+    minimum,
+    maximum,
+  };
+}
+
+function restartIntegerField(
+  path: string,
+  label: string,
+  description: string,
+  minimum: number,
+  maximum: number,
+): ModuleConfigFieldDescriptor {
+  return {
+    ...integerField(path, label, description, minimum, maximum),
+    applyMode: "restart",
+  };
+}
+
+function restartBooleanField(
+  path: string,
+  label: string,
+  description: string,
+): ModuleConfigFieldDescriptor {
+  return { path, label, description, input: "boolean", applyMode: "restart" };
+}
+
+function restartTextField(
+  path: string,
+  label: string,
+  description: string,
+): ModuleConfigFieldDescriptor {
+  return { path, label, description, input: "text", applyMode: "restart" };
+}
+
+function isSupportedTimeZone(value: string): boolean {
+  try {
+    new Intl.DateTimeFormat("zh-CN", { timeZone: value });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
 function assertSafeManagedPaths(): void {
   const fields = new Map(
     platformConfigDefinition.environment.map((field) => [field.path, field]),

package/template/apps/server/src/configuration/drizzle-repository.ts

@@ -1,7 +1,7 @@
 import { randomUUIDv7 } from "bun";
 import { moduleConfigVersions } from "@southwind-ai/database";
 import type { ModuleConfigVersion } from "@southwind-ai/shared";
-import { and, desc, eq, ne, sql } from "drizzle-orm";
+import { and, desc, eq, inArray, ne, sql } from "drizzle-orm";
 import type { NodePgDatabase } from "drizzle-orm/node-postgres";
 import type {
   BeginConfigVersionInput,
@@ -58,7 +58,10 @@ export class DrizzleModuleConfigVersionRepository implements ModuleConfigVersion
         .where(
           and(
             eq(moduleConfigVersions.moduleKey, candidate.moduleKey),
-            eq(moduleConfigVersions.applyStatus, "effective"),
+            inArray(moduleConfigVersions.applyStatus, [
+              "effective",
+              "pending-restart",
+            ]),
             ne(moduleConfigVersions.id, id),
           ),
         );
@@ -84,6 +87,37 @@ export class DrizzleModuleConfigVersionRepository implements ModuleConfigVersion
     return mapRequired(updated);
   }
 
+  async markPendingRestart(id: string): Promise<ModuleConfigVersion> {
+    return this.db.transaction(async (tx) => {
+      const [candidate] = await tx
+        .select()
+        .from(moduleConfigVersions)
+        .where(eq(moduleConfigVersions.id, id))
+        .limit(1);
+      if (!candidate) throw new Error("配置版本不存在");
+      await tx
+        .update(moduleConfigVersions)
+        .set({ applyStatus: "superseded" })
+        .where(
+          and(
+            eq(moduleConfigVersions.moduleKey, candidate.moduleKey),
+            eq(moduleConfigVersions.applyStatus, "pending-restart"),
+            ne(moduleConfigVersions.id, id),
+          ),
+        );
+      const [updated] = await tx
+        .update(moduleConfigVersions)
+        .set({
+          applyStatus: "pending-restart",
+          applyError: null,
+          appliedAt: null,
+        })
+        .where(eq(moduleConfigVersions.id, id))
+        .returning();
+      return mapRequired(updated);
+    });
+  }
+
   latest(moduleKey: string): Promise<ModuleConfigVersion | undefined> {
     return this.first(moduleKey);
   }

package/template/apps/server/src/configuration/repository.ts

@@ -18,6 +18,7 @@ export interface BeginConfigVersionInput {
 export interface ModuleConfigVersionRepository {
   begin(input: BeginConfigVersionInput): Promise<ModuleConfigVersion>;
   markEffective(id: string, appliedAt: Date): Promise<ModuleConfigVersion>;
+  markPendingRestart(id: string): Promise<ModuleConfigVersion>;
   markFailed(
     id: string,
     applyError: string,
@@ -61,7 +62,8 @@ export class InMemoryModuleConfigVersionRepository implements ModuleConfigVersio
     for (const candidate of this.versions) {
       if (
         candidate.moduleKey === version.moduleKey &&
-        candidate.applyStatus === "effective"
+        (candidate.applyStatus === "effective" ||
+          candidate.applyStatus === "pending-restart")
       ) {
         candidate.applyStatus = "superseded";
       }
@@ -84,6 +86,23 @@ export class InMemoryModuleConfigVersionRepository implements ModuleConfigVersio
     return cloneVersion(version);
   }
 
+  async markPendingRestart(id: string): Promise<ModuleConfigVersion> {
+    const version = this.required(id);
+    for (const candidate of this.versions) {
+      if (
+        candidate.id !== id &&
+        candidate.moduleKey === version.moduleKey &&
+        candidate.applyStatus === "pending-restart"
+      ) {
+        candidate.applyStatus = "superseded";
+      }
+    }
+    version.applyStatus = "pending-restart";
+    version.applyError = undefined;
+    version.appliedAt = undefined;
+    return cloneVersion(version);
+  }
+
   async latest(moduleKey: string): Promise<ModuleConfigVersion | undefined> {
     return this.sorted(moduleKey)[0];
   }
@@ -134,5 +153,11 @@ export function cloneVersion(
 }
 
 export function isApplyStatus(value: string): value is ModuleConfigApplyStatus {
-  return ["applying", "effective", "failed", "superseded"].includes(value);
+  return [
+    "applying",
+    "effective",
+    "failed",
+    "pending-restart",
+    "superseded",
+  ].includes(value);
 }

package/template/apps/server/src/configuration/routes.ts

@@ -176,7 +176,10 @@ function recordResult(
   version: ModuleConfigVersion,
 ): void {
   const outcome: AuditOutcome =
-    version.applyStatus === "effective" ? "success" : "failure";
+    version.applyStatus === "effective" ||
+    version.applyStatus === "pending-restart"
+      ? "success"
+      : "failure";
   runtime.auditSink.recordEvent({
     ...resourceEvent(
       context,

package/template/apps/server/src/configuration/service.test.ts

@@ -81,6 +81,106 @@ describe("模块配置版本服务", () => {
     expect(serialized).not.toContain("secret-value-marker");
     expect(serialized).not.toContain("SecretRef");
   });
+
+  test("重启字段保存为等待状态并在下一次启动提升为生效版本", async () => {
+    const repository = new InMemoryModuleConfigVersionRepository();
+    const current = { host: "old.smtp.local" };
+    const definition: ManagedModuleConfigDefinition = {
+      moduleKey: "mail.runtime",
+      label: "邮件传输配置",
+      fields: [
+        {
+          path: "host",
+          label: "SMTP 主机",
+          description: "重启后应用",
+          input: "text",
+          applyMode: "restart",
+        },
+      ],
+      validate(values) {
+        const input = values as Record<string, unknown>;
+        return { host: String(input.host || current.host) };
+      },
+      apply(values) {
+        current.host = values.host as string;
+      },
+      baseValues: () => ({ ...current }),
+    };
+    const service = new ModuleConfigurationService(repository, [definition]);
+
+    const created = await service.create(
+      "mail.runtime",
+      { host: "new.smtp.local" },
+      "user-1",
+    );
+
+    expect(created).toMatchObject({
+      ok: true,
+      version: { applyStatus: "pending-restart" },
+    });
+    expect(current.host).toBe("old.smtp.local");
+
+    const replacement = await service.create(
+      "mail.runtime",
+      { host: "corrected.smtp.local" },
+      "user-1",
+    );
+    expect(replacement).toMatchObject({
+      ok: true,
+      version: { version: 2, applyStatus: "pending-restart" },
+    });
+    expect((await service.summaries())[0]?.pendingValues).toEqual({
+      host: "corrected.smtp.local",
+    });
+    expect(
+      (await service.list("mail.runtime"))?.map((item) => item.applyStatus),
+    ).toEqual(["pending-restart", "superseded"]);
+
+    await new ModuleConfigurationService(repository, [definition]).initialize();
+
+    expect(current.host).toBe("corrected.smtp.local");
+    expect((await repository.latest("mail.runtime"))?.applyStatus).toBe(
+      "effective",
+    );
+  });
+
+  test("旧版本缺少新增字段时使用当前基线补齐", async () => {
+    const current = { enabled: false, timeoutMs: 300 };
+    const schema = z.strictObject({
+      enabled: z.boolean(),
+      timeoutMs: z.number().int(),
+    });
+    const definition: ManagedModuleConfigDefinition = {
+      moduleKey: "compatible.runtime",
+      label: "兼容配置",
+      fields: [],
+      validate(values) {
+        return schema.parse({
+          ...current,
+          ...(values as Record<string, unknown>),
+        });
+      },
+      apply(values) {
+        current.enabled = values.enabled as boolean;
+        current.timeoutMs = values.timeoutMs as number;
+      },
+      baseValues: () => ({ ...current }),
+    };
+    const repository = new InMemoryModuleConfigVersionRepository();
+    const version = await repository.begin({
+      moduleKey: definition.moduleKey,
+      values: { enabled: true },
+      diff: [],
+      actorId: "legacy",
+    });
+    await repository.markEffective(version.id, new Date());
+    const service = new ModuleConfigurationService(repository, [definition]);
+
+    await service.initialize();
+
+    expect(current).toEqual({ enabled: true, timeoutMs: 300 });
+    expect((await service.summaries())[0]?.effectiveValues).toEqual(current);
+  });
 });
 
 function createFixture(failApply = false) {

package/template/apps/server/src/configuration/service.ts

@@ -36,14 +36,21 @@ export class ModuleConfigurationService {
 
   async initialize(): Promise<void> {
     for (const definition of this.definitions.values()) {
-      const effective = await this.repository.effective(definition.moduleKey);
-      if (!effective) continue;
+      const latest = await this.repository.latest(definition.moduleKey);
+      const candidate =
+        latest?.applyStatus === "pending-restart"
+          ? latest
+          : await this.repository.effective(definition.moduleKey);
+      if (!candidate) continue;
       try {
-        const values = definition.validate(effective.values);
+        const values = definition.validate(candidate.values);
         await definition.apply(values);
+        if (candidate.applyStatus === "pending-restart") {
+          await this.repository.markEffective(candidate.id, new Date());
+        }
       } catch (error) {
         await this.repository.markFailed(
-          effective.id,
+          candidate.id,
           sanitizeApplyError(error),
           new Date(),
         );
@@ -62,9 +69,13 @@ export class ModuleConfigurationService {
           moduleKey: definition.moduleKey,
           label: definition.label,
           fields: definition.fields.map((field) => ({ ...field })),
-          effectiveValues: {
-            ...(effective?.values || definition.baseValues()),
-          },
+          effectiveValues: definition.validate(
+            effective?.values || definition.baseValues(),
+          ),
+          pendingValues:
+            latest?.applyStatus === "pending-restart"
+              ? definition.validate(latest.values)
+              : undefined,
           effectiveSource: effective ? "version" : "environment",
           effectiveVersion: effective?.version,
           latestVersion: latest?.version,
@@ -129,16 +140,33 @@ export class ModuleConfigurationService {
     reason?: string,
     rollbackOfVersion?: number,
   ): Promise<ConfigVersionResult> {
-    const effective = await this.repository.effective(definition.moduleKey);
-    const before = effective?.values || definition.baseValues();
+    const [effective, latest] = await Promise.all([
+      this.repository.effective(definition.moduleKey),
+      this.repository.latest(definition.moduleKey),
+    ]);
+    const before = definition.validate(
+      latest?.applyStatus === "pending-restart"
+        ? latest.values
+        : effective?.values || definition.baseValues(),
+    );
+    const diff = configDiff(before, values);
     const version = await this.repository.begin({
       moduleKey: definition.moduleKey,
       values,
-      diff: configDiff(before, values),
+      diff,
       rollbackOfVersion,
       reason,
       actorId,
     });
+    if (
+      latest?.applyStatus === "pending-restart" ||
+      requiresRestart(definition, diff)
+    ) {
+      return {
+        ok: true,
+        version: await this.repository.markPendingRestart(version.id),
+      };
+    }
     try {
       await definition.apply(values);
       return {
@@ -158,6 +186,18 @@ export class ModuleConfigurationService {
   }
 }
 
+function requiresRestart(
+  definition: ManagedModuleConfigDefinition,
+  diff: ModuleConfigDiffEntry[],
+): boolean {
+  const restartPaths = new Set(
+    definition.fields
+      .filter((field) => field.applyMode === "restart")
+      .map((field) => field.path),
+  );
+  return diff.some((entry) => restartPaths.has(entry.path));
+}
+
 export function configDiff(
   before: ModuleConfigValues,
   after: ModuleConfigValues,

package/template/apps/server/src/data-access/scoped-repository.integration.test.ts

@@ -133,9 +133,10 @@ function createRepositories(pool: Pool) {
 async function seedDepartments(
   repository: ReturnType<typeof createRepositories>["departments"],
 ) {
-  await repository.create(department("dept_a"), setupActor);
+  await repository.create(department("org_root"), setupActor);
+  await repository.create(department("dept_a", "org_root"), setupActor);
   await repository.create(department("dept_a_child", "dept_a"), setupActor);
-  await repository.create(department("dept_b"), setupActor);
+  await repository.create(department("dept_b", "org_root"), setupActor);
 }
 
 async function seedUsers(

package/template/apps/server/src/data-governance/export/service.ts

@@ -1,6 +1,6 @@
 import type { GovernedExportQuerySnapshot } from "@southwind-ai/database";
 import type { AuditEvent } from "@southwind-ai/shared";
-import type { RequestGuardContext } from "../../guards.js";
+import { auditActor, type RequestGuardContext } from "../../guards.js";
 import {
   DurableArtifactError,
   type DurableArtifactService,
@@ -310,11 +310,7 @@ function event(
     id: Bun.randomUUIDv7(),
     action,
     outcome: "success",
-    actor: {
-      id: context.actor.id,
-      type: context.actor.type === "anonymous" ? "user" : context.actor.type,
-      name: context.actor.name,
-    },
+    actor: auditActor(context),
     target: { type: "system.user.governed-export", id },
     requestId: context.requestId,
     metadata,