create-windy 0.3.0 → 0.3.2

package/template/apps/server/src/index.ts

@@ -26,10 +26,7 @@ import { GovernedToolRegistry } from "./agent/tool-registry.js";
 import { PlatformMcpAdapter } from "./mcp/adapter.js";
 import { registerMcpRoutes } from "./mcp/routes.js";
 // @windy-module system.agent end
-import { registerAuthRoutes, registerAuthSessionRoute } from "./auth/routes.js";
 import { createAuthRuntime } from "./auth/runtime.js";
-import { createPlatformHttpApp } from "./http-app.js";
-import { bootstrapAdminPassword } from "./auth/bootstrap-admin.js";
 import { createServerPersistence } from "./persistence.js";
 // @windy-module system.license begin
 import { registerPlatformLicenseRoutes } from "./license/routes.js";
@@ -51,7 +48,6 @@ import { SchedulerWorker } from "./scheduler/worker.js";
 // @windy-module system.settings begin
 import { createPlatformSettingsRuntime } from "./settings/runtime.js";
 // @windy-module system.settings end
-import { registerProfileRoutes } from "./profile/routes.js";
 // @windy-module system.notification begin
 import { registerNotificationRoutes } from "./notification/routes.js";
 // @windy-module system.notification end
@@ -76,11 +72,13 @@ import { createSearchHost } from "./search/host.js";
 // @windy-module system.workflow begin
 import { registerWorkflowRoutes } from "./workflow/routes.js";
 // @windy-module system.workflow end
-import {
-  createPlatformObservability,
-  logPlatformStartup,
-} from "./observability/bootstrap.js";
 import { bootstrapServerModules } from "./module-bootstrap.js";
+import {
+  createHttpObservability,
+  createPlatformServerApp,
+  listenPlatformServer,
+  logServerStartup,
+} from "./platform-http-runtime.js";
 
 const logger = pino({ name: "windy-server" });
 const platformConfig = loadPlatformConfig();
@@ -128,14 +126,7 @@ const runtime = createServerRuntime(process.env, {
   auditWriter: persistence?.auditWriter,
   // @windy-module system.audit end
 });
-const observability = createPlatformObservability({
-  databaseCheck: persistence
-    ? async () => void (await persistence.pool.query("select 1"))
-    : undefined,
-  databaseRequired: process.env.NODE_ENV === "production",
-  auditStatus: () => runtime.auditSink.status(),
-  logger,
-});
+const observability = createHttpObservability(runtime, persistence, logger);
 // @windy-module system.license begin
 platformLicenseRuntime.setAuditSink(runtime.auditSink);
 // @windy-module system.license end
@@ -208,20 +199,17 @@ const schedulerWorker = new SchedulerWorker(
   (result) => observability.metrics.observeSchedulerTick(result),
 );
 // @windy-module system.scheduler end
-await bootstrapAdminPassword({
+const app = await createPlatformServerApp({
+  runtime,
+  persistence,
+  platformConfig,
+  authRepository,
   authService,
-  authRepository: persistence?.authRepository,
   repositories: systemRepositories,
-  password: process.env.WINDY_BOOTSTRAP_ADMIN_PASSWORD,
-});
-const app = createPlatformHttpApp(runtime, observability);
-observability.register(app);
-registerAuthSessionRoute(app);
-registerAuthRoutes(app, authService, {
-  sessionCookieName: platformConfig.security.sessionCookieName,
-  secureCookie: process.env.NODE_ENV === "production",
+  features,
+  logger,
+  observability,
 });
-registerProfileRoutes(app, authRepository, runtime, features);
 
 // @windy-module system.license begin
 registerPlatformLicenseRoutes(app, platformLicenseRuntime);
@@ -354,13 +342,8 @@ validateInstalledRuntime({
   hosts: moduleHosts,
 });
 
-const port = process.env.PORT ? Number(process.env.PORT) : 9_747;
-app.listen(port);
+const port = listenPlatformServer(app);
 // @windy-module system.scheduler begin
 schedulerWorker.start();
 // @windy-module system.scheduler end
-logPlatformStartup(logger, {
-  featureSync,
-  persistenceEnabled: Boolean(persistence),
-  port,
-});
+logServerStartup(logger, featureSync, Boolean(persistence), port);

package/template/apps/server/src/mcp/adapter.test.ts

@@ -1,6 +1,7 @@
 import { afterEach, describe, expect, test } from "bun:test";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { MCP_API_PATH } from "@southwind-ai/shared";
 import { createFoundationSnapshot, loadSystemModules } from "../foundation.js";
 import { createServerRuntime } from "../runtime.js";
 import { createSystemRepositories } from "../system/seed.js";
@@ -150,7 +151,7 @@ async function connectClient(
   token: string,
 ): Promise<Client> {
   const transport = new StreamableHTTPClientTransport(
-    new URL("http://localhost/api/mcp"),
+    new URL(`http://localhost${MCP_API_PATH}`),
     {
       requestInit: {
         headers: { authorization: `Bearer ${token}` },
@@ -175,7 +176,7 @@ function mcpRequest(token?: string, origin?: string): Request {
   });
   if (token) headers.set("authorization", `Bearer ${token}`);
   if (origin) headers.set("origin", origin);
-  return new Request("http://localhost/api/mcp", {
+  return new Request(`http://localhost${MCP_API_PATH}`, {
     method: "POST",
     headers,
     body: JSON.stringify({

package/template/apps/server/src/mcp/adapter.ts

@@ -10,7 +10,10 @@ import type {
   ModuleToolInput,
   ModuleToolResult,
 } from "@southwind-ai/server-sdk";
-import type { FeatureFlagDefinition } from "@southwind-ai/shared";
+import {
+  MCP_SERVER_INFO,
+  type FeatureFlagDefinition,
+} from "@southwind-ai/shared";
 import { evaluateAccessGuards } from "../access-guards.js";
 import type { RequestGuardContext } from "../guards.js";
 import { findFeature } from "../route-guards.js";
@@ -69,14 +72,11 @@ export class PlatformMcpAdapter {
   }
 
   private createServer(context: RequestGuardContext): Server {
-    const server = new Server(
-      { name: "windy-platform", version: "0.1.0" },
-      {
-        capabilities: { tools: {} },
-        instructions:
-          "仅调用当前账号可见的只读业务工具；权限和数据范围由 Windy 平台逐次校验。",
-      },
-    );
+    const server = new Server(MCP_SERVER_INFO, {
+      capabilities: { tools: {} },
+      instructions:
+        "仅调用当前账号可见的只读业务工具；权限和数据范围由 Windy 平台逐次校验。",
+    });
 
     server.setRequestHandler(ListToolsRequestSchema, async () => ({
       tools: await this.allowedQueryTools(context),

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

@@ -1,3 +1,4 @@
+import { MCP_ROUTE_PATH } from "@southwind-ai/shared";
 import type { RouteApp } from "../system/routes.js";
 import { PlatformMcpAdapter } from "./adapter.js";
 
@@ -15,7 +16,7 @@ export function registerMcpRoutes(
     const context = rawContext as McpRouteContext;
     return adapter.handle(context.request, context.guardContext, context.body);
   };
-  app.get("/mcp", handle);
-  app.post("/mcp", handle);
-  app.delete("/mcp", handle);
+  app.get(MCP_ROUTE_PATH, handle);
+  app.post(MCP_ROUTE_PATH, handle);
+  app.delete(MCP_ROUTE_PATH, handle);
 }

package/template/apps/server/src/platform-http-runtime.ts

@@ -0,0 +1,87 @@
+import type { PlatformConfig } from "@southwind-ai/config";
+import type { FeatureFlagDefinition } from "@southwind-ai/shared";
+import type { AuthRepository } from "./auth/repository.js";
+import type { AuthService } from "./auth/service.js";
+import { bootstrapAdminPassword } from "./auth/bootstrap-admin.js";
+import { registerAuthRoutes, registerAuthSessionRoute } from "./auth/routes.js";
+import { createPlatformHttpApp } from "./http-app.js";
+import {
+  createPlatformObservability,
+  logPlatformStartup,
+} from "./observability/bootstrap.js";
+import type { StructuredRequestLogger } from "./observability/http-observability.js";
+import type { createServerPersistence } from "./persistence.js";
+import { registerProfileRoutes } from "./profile/routes.js";
+import type { createServerRuntime } from "./runtime.js";
+import type { SystemRepositories } from "./system/seed.js";
+import type { FeatureManifestSyncResult } from "./feature/manifest-feature-repository.js";
+
+interface CreatePlatformServerAppInput {
+  runtime: ReturnType<typeof createServerRuntime>;
+  persistence: ReturnType<typeof createServerPersistence>;
+  platformConfig: PlatformConfig;
+  authRepository: AuthRepository;
+  authService: AuthService;
+  repositories: SystemRepositories;
+  features: FeatureFlagDefinition[];
+  logger: StructuredRequestLogger;
+  observability: ReturnType<typeof createPlatformObservability>;
+}
+
+export function createHttpObservability(
+  runtime: ReturnType<typeof createServerRuntime>,
+  persistence: ReturnType<typeof createServerPersistence>,
+  logger: StructuredRequestLogger,
+) {
+  const database = persistence;
+  return createPlatformObservability({
+    databaseCheck: database
+      ? async () => void (await database.pool.query("select 1"))
+      : undefined,
+    databaseRequired: process.env.NODE_ENV === "production",
+    auditStatus: () => runtime.auditSink.status(),
+    logger,
+  });
+}
+
+export async function createPlatformServerApp(
+  input: CreatePlatformServerAppInput,
+) {
+  await bootstrapAdminPassword({
+    authService: input.authService,
+    authRepository: input.persistence?.authRepository,
+    repositories: input.repositories,
+    password: process.env.WINDY_BOOTSTRAP_ADMIN_PASSWORD,
+  });
+  const app = createPlatformHttpApp(input.runtime, input.observability);
+  input.observability.register(app);
+  registerAuthSessionRoute(app);
+  registerAuthRoutes(app, input.authService, {
+    sessionCookieName: input.platformConfig.security.sessionCookieName,
+    secureCookie: process.env.NODE_ENV === "production",
+  });
+  registerProfileRoutes(
+    app,
+    input.authRepository,
+    input.runtime,
+    input.features,
+  );
+  return app;
+}
+
+export function listenPlatformServer(
+  app: ReturnType<typeof createPlatformHttpApp>,
+): number {
+  const port = process.env.PORT ? Number(process.env.PORT) : 9_747;
+  app.listen(port);
+  return port;
+}
+
+export function logServerStartup(
+  logger: StructuredRequestLogger,
+  featureSync: FeatureManifestSyncResult,
+  persistenceEnabled: boolean,
+  port: number,
+): void {
+  logPlatformStartup(logger, { featureSync, persistenceEnabled, port });
+}

package/template/apps/server/src/system/drizzle-system-configs.ts

@@ -0,0 +1,319 @@
+import {
+  departments,
+  dictionaries,
+  featureFlags,
+  // @windy-module system.license begin
+  legacyLicenses,
+  // @windy-module system.license end
+  menus,
+  roles,
+  users,
+} from "@southwind-ai/database";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import type {
+  ManagedDepartment,
+  ManagedDictionary,
+  ManagedFeature,
+  // @windy-module system.license begin
+  ManagedLicense,
+  // @windy-module system.license end
+  ManagedMenu,
+  ManagedRole,
+  ManagedUser,
+} from "./entities.js";
+import {
+  array,
+  auditEntity,
+  auditRow,
+  // @windy-module system.license begin
+  date,
+  iso,
+  optionalIso,
+  // @windy-module system.license end
+  pick,
+} from "./drizzle-mapping.js";
+import {
+  DrizzleEntityRepository,
+  type DrizzleEntityRepositoryConfig,
+} from "./drizzle-repository.js";
+import type { DrizzleScopedEntityRepositoryConfig } from "./drizzle-scoped-repository.js";
+import type { DrizzleTransactionContext } from "./drizzle-transaction-context.js";
+import { userDataScopeBinding } from "./user-data-scope.js";
+
+type SystemEntity =
+  | ManagedUser
+  | ManagedRole
+  | ManagedDepartment
+  | ManagedMenu
+  | ManagedDictionary
+  | ManagedFeature
+  // @windy-module system.license begin
+  | ManagedLicense;
+// @windy-module system.license end
+
+export function createSystemEntityRepository<T extends SystemEntity>(
+  db: NodePgDatabase,
+  config: DrizzleEntityRepositoryConfig<T>,
+  transactionContext: DrizzleTransactionContext,
+) {
+  return new DrizzleEntityRepository<T>(db, config, transactionContext);
+}
+
+export function userConfig(
+  seedItems: ManagedUser[],
+): DrizzleScopedEntityRepositoryConfig<ManagedUser> {
+  return {
+    table: users,
+    idColumn: "id",
+    seedItems,
+    dataScope: {
+      drizzle: {
+        ownerId: users.id,
+        tenant: { mode: "fixed", tenantId: "single-tenant" },
+        dimensions: { departmentId: users.departmentId },
+      },
+      entity: userDataScopeBinding,
+    },
+    toRow: (item) => ({
+      ...auditRow(item),
+      ...pick(item, [
+        "id",
+        "username",
+        "displayName",
+        "email",
+        "phone",
+        "departmentId",
+        "roleIds",
+        "postIds",
+        "status",
+      ]),
+    }),
+    toEntity: (row) =>
+      ({
+        ...auditEntity(row),
+        ...pick(row, [
+          "id",
+          "username",
+          "displayName",
+          "email",
+          "phone",
+          "departmentId",
+          "postIds",
+          "status",
+        ]),
+        roleIds: array(row.roleIds),
+      }) as ManagedUser,
+  };
+}
+
+export function roleConfig(
+  seedItems: ManagedRole[],
+): DrizzleEntityRepositoryConfig<ManagedRole> {
+  return {
+    table: roles,
+    idColumn: "id",
+    seedItems,
+    toRow: (item) => ({
+      ...auditRow(item),
+      ...pick(item, [
+        "id",
+        "code",
+        "name",
+        "dataScope",
+        "permissionKeys",
+        "menuKeys",
+        "departmentIds",
+        "status",
+      ]),
+    }),
+    toEntity: (row) =>
+      ({
+        ...auditEntity(row),
+        ...pick(row, ["id", "code", "name", "dataScope", "status"]),
+        permissionKeys: array(row.permissionKeys),
+        menuKeys: array(row.menuKeys),
+        departmentIds: array(row.departmentIds),
+      }) as ManagedRole,
+  };
+}
+
+export function departmentConfig(
+  seedItems: ManagedDepartment[],
+): DrizzleEntityRepositoryConfig<ManagedDepartment> {
+  return {
+    table: departments,
+    idColumn: "id",
+    seedItems,
+    toRow: (item) => ({
+      ...auditRow(item),
+      ...pick(item, ["id", "parentId", "name", "code", "order", "status"]),
+    }),
+    toEntity: (row) =>
+      ({
+        ...auditEntity(row),
+        ...pick(row, ["id", "parentId", "name", "code", "order", "status"]),
+      }) as ManagedDepartment,
+  };
+}
+
+export function menuConfig(
+  seedItems: ManagedMenu[],
+): DrizzleEntityRepositoryConfig<ManagedMenu> {
+  return {
+    table: menus,
+    idColumn: "id",
+    seedItems,
+    toRow: (item) => ({
+      ...auditRow(item),
+      ...pick(item, [
+        "id",
+        "key",
+        "title",
+        "type",
+        "order",
+        "path",
+        "component",
+        "icon",
+        "permissionKey",
+        "featureKey",
+        "parentKey",
+        "status",
+      ]),
+      visible: item.visible ? "visible" : "hidden",
+    }),
+    toEntity: (row) =>
+      ({
+        ...auditEntity(row),
+        ...pick(row, [
+          "id",
+          "key",
+          "title",
+          "type",
+          "order",
+          "path",
+          "component",
+          "icon",
+          "permissionKey",
+          "featureKey",
+          "parentKey",
+          "status",
+        ]),
+        visible: row.visible !== "hidden",
+      }) as ManagedMenu,
+  };
+}
+
+export function dictionaryConfig(
+  seedItems: ManagedDictionary[],
+): DrizzleEntityRepositoryConfig<ManagedDictionary> {
+  return {
+    table: dictionaries,
+    idColumn: "id",
+    seedItems,
+    toRow: (item) => ({
+      ...auditRow(item),
+      ...pick(item, ["id", "code", "name", "description", "status"]),
+      items: item.items || [],
+    }),
+    toEntity: (row) =>
+      ({
+        ...auditEntity(row),
+        ...pick(row, ["id", "code", "name", "description", "status"]),
+        items: array(row.items),
+      }) as ManagedDictionary,
+  };
+}
+
+export function featureConfig(
+  seedItems: ManagedFeature[],
+): DrizzleEntityRepositoryConfig<ManagedFeature> {
+  return {
+    table: featureFlags,
+    idColumn: "key",
+    seedItems,
+    toRow: (item) => ({
+      ...auditRow(item),
+      key: item.key || item.id,
+      module: item.module,
+      label: item.label,
+      description: item.description,
+      enabled: item.enabled,
+      visible: item.visible,
+      stage: item.stage,
+      licenseRequired: false,
+      licenseKey: item.requiredEntitlement,
+      allowedLicenseVersions: item.licenseVersionOverride,
+      dependencies: item.dependencies || [],
+      status: item.status,
+    }),
+    toEntity: (row) =>
+      ({
+        ...auditEntity(row),
+        id: String(row.key),
+        key: String(row.key),
+        module: String(row.module),
+        label: String(row.label),
+        description: row.description as string | undefined,
+        enabled: Boolean(row.enabled),
+        visible: row.visible === "hidden" ? "hidden" : "visible",
+        stage: String(row.stage || "stable") as ManagedFeature["stage"],
+        requiredEntitlement: row.licenseKey
+          ? (row.licenseKey as NonNullable<
+              ManagedFeature["requiredEntitlement"]
+            >)
+          : undefined,
+        licenseVersionOverride: Array.isArray(row.allowedLicenseVersions)
+          ? (row.allowedLicenseVersions as NonNullable<
+              ManagedFeature["licenseVersionOverride"]
+            >)
+          : undefined,
+        dependencies: array(row.dependencies),
+        status: String(row.status || "active") as ManagedFeature["status"],
+      }) as ManagedFeature,
+  };
+}
+
+// @windy-module system.license begin
+export function licenseConfig(
+  seedItems: ManagedLicense[],
+): DrizzleEntityRepositoryConfig<ManagedLicense> {
+  return {
+    table: legacyLicenses,
+    idColumn: "id",
+    seedItems,
+    toRow: (item) => ({
+      ...auditRow(item),
+      ...pick(item, [
+        "id",
+        "licenseKey",
+        "subject",
+        "machineCode",
+        "publicKeyId",
+        "edition",
+        "modules",
+        "status",
+      ]),
+      issuedAt: date(item.issuedAt),
+      expiresAt: item.expiresAt ? date(item.expiresAt) : undefined,
+      payload: { modules: item.modules },
+      signature: "",
+    }),
+    toEntity: (row) =>
+      ({
+        ...auditEntity(row),
+        ...pick(row, [
+          "id",
+          "licenseKey",
+          "subject",
+          "machineCode",
+          "publicKeyId",
+          "edition",
+          "status",
+        ]),
+        modules: array(row.modules),
+        issuedAt: iso(row.issuedAt),
+        expiresAt: optionalIso(row.expiresAt),
+      }) as ManagedLicense,
+  };
+}
+// @windy-module system.license end