create-windy 0.2.7 → 0.2.8

package/template/apps/server/src/license/license-resolver.ts

@@ -1,9 +1,9 @@
-import { licenseKeys, licenses } from "@windy/database";
+import { licenseKeys, licenses } from "@southwind-ai/database";
 import {
   parseLicenseSigningDocument,
   verifyLicensePayloadSignature,
-} from "@windy/license-sdk";
-import type { LicenseV1Claims } from "@windy/shared";
+} from "@southwind-ai/license";
+import type { LicenseV1Claims } from "@southwind-ai/shared";
 import { and, desc, eq, gt } from "drizzle-orm";
 import type { NodePgDatabase } from "drizzle-orm/node-postgres";
 import type {

package/template/apps/server/src/license/routes-offline-code.test.ts

@@ -4,8 +4,8 @@ import {
   canonicalizeJson,
   encodeOfflineActivationCode,
   LICENSE_V1_TEST_VECTOR,
-} from "@windy/license-sdk";
-import type { SignedLicenseV1 } from "@windy/shared";
+} from "@southwind-ai/license";
+import type { SignedLicenseV1 } from "@southwind-ai/shared";
 import { registerPlatformLicenseRoutes } from "./routes.js";
 import type { PlatformLicenseRuntime } from "./runtime-service.js";
 

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

@@ -7,7 +7,7 @@ import {
   OfflineActivationCodeError,
   offlineActivationCodeErrorMessage,
   readBoundedJsonObject,
-} from "@windy/license-sdk";
+} from "@southwind-ai/license";
 
 interface LicenseRouteContext {
   guardContext: RequestGuardContext;

package/template/apps/server/src/license/runtime-audit-reliability.test.ts

@@ -3,12 +3,12 @@ import { describe, expect, test } from "bun:test";
 import {
   createLicenseSigningPayload,
   MemoryAtomicLicenseStore,
-} from "@windy/license-sdk";
+} from "@southwind-ai/license";
 import {
   licenseVersionKey,
   type LicenseV1Claims,
   type SignedLicenseV1,
-} from "@windy/shared";
+} from "@southwind-ai/shared";
 import { MemoryAuditRecoveryQueue } from "../audit/recovery-queue.js";
 import { ReliableAuditWriter } from "../audit/reliable-writer.js";
 import { InMemoryAuditSink } from "../runtime.js";

package/template/apps/server/src/license/runtime-reminder.test.ts

@@ -3,12 +3,12 @@ import { describe, expect, test } from "bun:test";
 import {
   createLicenseSigningPayload,
   MemoryAtomicLicenseStore,
-} from "@windy/license-sdk";
+} from "@southwind-ai/license";
 import {
   licenseVersionKey,
   type LicenseV1Claims,
   type SignedLicenseV1,
-} from "@windy/shared";
+} from "@southwind-ai/shared";
 import type { RequestActor } from "../guards.js";
 import { PlatformLicenseRuntime } from "./runtime-service.js";
 

package/template/apps/server/src/license/runtime-service.test.ts

@@ -4,13 +4,13 @@ import { Elysia } from "elysia";
 import {
   createLicenseSigningPayload,
   MemoryAtomicLicenseStore,
-} from "@windy/license-sdk";
+} from "@southwind-ai/license";
 import {
   featureKey,
   licenseVersionKey,
   type LicenseV1Claims,
   type SignedLicenseV1,
-} from "@windy/shared";
+} from "@southwind-ai/shared";
 import { evaluateAccessGuards } from "../access-guards.js";
 import {
   createSystemToolHandlers,

package/template/apps/server/src/license/runtime-service.ts

@@ -11,12 +11,12 @@ import {
   type LicenseInstallResult,
   type LicensePublicKeyMap,
   type LicenseStorage,
-} from "@windy/license-sdk";
+} from "@southwind-ai/license";
 import type {
   AuditEvent,
   LicenseFailureReason,
   SignedLicense,
-} from "@windy/shared";
+} from "@southwind-ai/shared";
 import type { RequestActor } from "../guards.js";
 import type { InMemoryAuditSink } from "../runtime.js";
 import type {

package/template/apps/server/src/module-composition.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import type { ModuleManifest } from "@windy/modules";
+import type { ModuleManifest } from "@southwind-ai/modules";
 import { Elysia } from "elysia";
 import { validateServerModuleComposition } from "./module-composition.js";
 

package/template/apps/server/src/module-composition.ts

@@ -2,7 +2,7 @@ import {
   apiRouteKey,
   validateModuleComposition,
   type ModuleManifest,
-} from "@windy/modules";
+} from "@southwind-ai/modules";
 interface RegisteredHttpRoute {
   method: string;
   path: string;

package/template/apps/server/src/module-host.test.ts

@@ -0,0 +1,145 @@
+import { describe, expect, test } from "bun:test";
+import { DurableHandlerRegistry } from "@southwind-ai/jobs";
+import type { ModuleInitializer } from "@southwind-ai/server-sdk";
+import { workOrderModuleInitializer } from "./example-modules.js";
+import { initializeModuleHosts } from "./module-host.js";
+import {
+  createStorageRuntime,
+  platformUploadPolicies,
+} from "./storage/runtime.js";
+
+describe("模块 Host 初始化", () => {
+  test("按安装顺序完成初始化后再创建运行时注册表", async () => {
+    const events: string[] = [];
+    const first = initializer("alpha", async (host) => {
+      events.push("alpha:start");
+      await Promise.resolve();
+      host.registerDurableHandler({
+        key: "alpha.refresh",
+        payload: { parse: () => ({}) },
+        execute: () => undefined,
+      });
+      events.push("alpha:end");
+    });
+    const second = initializer("beta", () => {
+      events.push("beta");
+    });
+
+    const initialized = await initializeModuleHosts({
+      modules: [{ name: "alpha" }, { name: "beta" }],
+      initializers: [first, second],
+    });
+    expect(events).toEqual(["alpha:start", "alpha:end", "beta"]);
+
+    const registry = new DurableHandlerRegistry();
+    initialized.installDurableHandlers(registry);
+    expect(registry.keys()).toEqual(["alpha.refresh"]);
+  });
+
+  test("未知模块、错误命名空间和重复注册立即失败", async () => {
+    await expect(
+      initializeModuleHosts({
+        modules: [{ name: "known" }],
+        initializers: [initializer("missing", () => undefined)],
+      }),
+    ).rejects.toThrow("模块初始化器与已安装模块不匹配：missing");
+
+    await expect(
+      initializeModuleHosts({
+        modules: [{ name: "known" }],
+        initializers: [
+          initializer("known", (host) => {
+            host.registerUploadPolicy(policy("other.attachment"));
+          }),
+        ],
+      }),
+    ).rejects.toThrow("上传用途不属于模块 known：other.attachment");
+
+    await expect(
+      initializeModuleHosts({
+        modules: [{ name: "known" }],
+        initializers: [
+          initializer("known", (host) => {
+            host.registerUploadPolicy(policy("known.attachment"));
+            host.registerUploadPolicy(policy("known.attachment"));
+          }),
+        ],
+      }),
+    ).rejects.toThrow("上传用途重复注册：known.attachment");
+
+    await expect(
+      initializeModuleHosts({
+        modules: [],
+        initializers: [],
+        baseUploadPolicies: [policy("platform.file"), policy("platform.file")],
+      }),
+    ).rejects.toThrow("上传用途重复注册：platform.file");
+
+    await expect(
+      initializeModuleHosts({
+        modules: [{ name: "known" }],
+        initializers: [
+          initializer("known", (host) => {
+            const definition = {
+              key: "known.refresh",
+              payload: { parse: () => ({}) },
+              execute: () => undefined,
+            };
+            host.registerDurableHandler(definition);
+            host.registerDurableHandler(definition);
+          }),
+        ],
+      }),
+    ).rejects.toThrow("任务 handler 重复注册：known.refresh");
+  });
+
+  test("work-order 附件策略只随模块初始化并被上传运行时采用", async () => {
+    const withoutWorkOrder = await initializeModuleHosts({
+      modules: [],
+      initializers: [],
+      baseUploadPolicies: platformUploadPolicies,
+    });
+    expect(
+      withoutWorkOrder.uploadPolicies.some(
+        ({ purpose }) => purpose === "work-order.ticket.attachment",
+      ),
+    ).toBe(false);
+
+    const withWorkOrder = await initializeModuleHosts({
+      modules: [{ name: "work-order" }],
+      initializers: [workOrderModuleInitializer],
+      baseUploadPolicies: platformUploadPolicies,
+    });
+    const storage = createStorageRuntime(
+      {},
+      undefined,
+      withWorkOrder.uploadPolicies,
+    );
+    const session = await storage.uploads.create({
+      ownerId: "user-1",
+      purpose: "work-order.ticket.attachment",
+      filename: "现场照片.jpg",
+      mimeType: "image/jpeg",
+      expectedByteSize: 1024,
+    });
+    expect(session.purpose).toBe("work-order.ticket.attachment");
+  });
+});
+
+function initializer(
+  moduleName: string,
+  initialize: ModuleInitializer["initialize"],
+): ModuleInitializer {
+  return { moduleName, initialize };
+}
+
+function policy(purpose: string) {
+  return {
+    purpose,
+    maxByteSize: 1024,
+    maxPartByteSize: 512,
+    sessionTtlMs: 60_000,
+    allowedTypes: { "text/plain": ["txt"] },
+    signature: "none" as const,
+  };
+}

package/template/apps/server/src/module-host.ts

@@ -0,0 +1,110 @@
+import {
+  DurableHandlerRegistry,
+  type DurableHandlerDefinition,
+} from "@southwind-ai/jobs";
+import type { ModuleHost, ModuleInitializer } from "@southwind-ai/server-sdk";
+import type { UploadPolicy } from "@southwind-ai/storage";
+
+interface InstalledModule {
+  name: string;
+}
+
+export interface InitializeModuleHostsInput {
+  modules: readonly InstalledModule[];
+  initializers: readonly ModuleInitializer[];
+  baseUploadPolicies?: readonly UploadPolicy[];
+}
+
+export interface InitializedModuleHosts {
+  readonly uploadPolicies: readonly UploadPolicy[];
+  installDurableHandlers(registry: DurableHandlerRegistry): void;
+}
+
+type HandlerInstaller = (registry: DurableHandlerRegistry) => void;
+
+export async function initializeModuleHosts(
+  input: InitializeModuleHostsInput,
+): Promise<InitializedModuleHosts> {
+  const installedNames = new Set(input.modules.map(({ name }) => name));
+  const initializedNames = new Set<string>();
+  const uploadPolicies: UploadPolicy[] = [];
+  const uploadPurposes = new Set<string>();
+  for (const policy of input.baseUploadPolicies ?? []) {
+    if (uploadPurposes.has(policy.purpose)) {
+      throw new Error(`上传用途重复注册：${policy.purpose}`);
+    }
+    uploadPurposes.add(policy.purpose);
+    uploadPolicies.push(policy);
+  }
+  const handlerKeys = new Set<string>();
+  const handlerInstallers: HandlerInstaller[] = [];
+
+  for (const initializer of input.initializers) {
+    const moduleName = initializer.moduleName.trim();
+    if (!installedNames.has(moduleName)) {
+      throw new Error(`模块初始化器与已安装模块不匹配：${moduleName}`);
+    }
+    if (initializedNames.has(moduleName)) {
+      throw new Error(`模块初始化器重复注册：${moduleName}`);
+    }
+    initializedNames.add(moduleName);
+    await initializer.initialize(
+      createScopedHost({
+        moduleName,
+        uploadPolicies,
+        uploadPurposes,
+        handlerKeys,
+        handlerInstallers,
+      }),
+    );
+  }
+
+  return {
+    uploadPolicies: [...uploadPolicies],
+    installDurableHandlers(registry) {
+      for (const install of handlerInstallers) install(registry);
+    },
+  };
+}
+
+interface ScopedHostState {
+  moduleName: string;
+  uploadPolicies: UploadPolicy[];
+  uploadPurposes: Set<string>;
+  handlerKeys: Set<string>;
+  handlerInstallers: HandlerInstaller[];
+}
+
+function createScopedHost(state: ScopedHostState): ModuleHost {
+  return {
+    moduleName: state.moduleName,
+    registerUploadPolicy(policy) {
+      requireModuleNamespace("上传用途", policy.purpose, state.moduleName);
+      if (state.uploadPurposes.has(policy.purpose)) {
+        throw new Error(`上传用途重复注册：${policy.purpose}`);
+      }
+      state.uploadPurposes.add(policy.purpose);
+      state.uploadPolicies.push(policy);
+    },
+    registerDurableHandler<T>(definition: DurableHandlerDefinition<T>) {
+      requireModuleNamespace("任务 handler", definition.key, state.moduleName);
+      if (state.handlerKeys.has(definition.key)) {
+        throw new Error(`任务 handler 重复注册：${definition.key}`);
+      }
+      state.handlerKeys.add(definition.key);
+      state.handlerInstallers.push((registry) => {
+        registry.register(definition);
+      });
+    },
+  };
+}
+
+function requireModuleNamespace(
+  kind: string,
+  value: string,
+  moduleName: string,
+): void {
+  if (value !== moduleName && !value.startsWith(`${moduleName}.`)) {
+    throw new Error(`${kind}不属于模块 ${moduleName}：${value}`);
+  }
+}

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

@@ -1,10 +1,10 @@
-import { notificationReads, platformNotifications } from "@windy/database";
+import { notificationReads, platformNotifications } from "@southwind-ai/database";
 import type {
   NotificationInboxItem,
   PageResult,
   PlatformNotification,
   PublishNotificationInput,
-} from "@windy/shared";
+} from "@southwind-ai/shared";
 import { and, desc, eq, ilike, isNull, or, sql, type SQL } from "drizzle-orm";
 import type { NodePgDatabase } from "drizzle-orm/node-postgres";
 import type { RequestActor } from "../guards.js";

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

@@ -5,7 +5,7 @@ import type {
   PageResult,
   PlatformNotification,
   PublishNotificationInput,
-} from "@windy/shared";
+} from "@southwind-ai/shared";
 import type { RequestActor } from "../guards.js";
 
 export interface NotificationRepository {

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

@@ -4,7 +4,7 @@ import type {
   FeatureFlagDefinition,
   HttpMethod,
   PublishNotificationInput,
-} from "@windy/shared";
+} from "@southwind-ai/shared";
 import type { RequestGuardContext } from "../guards.js";
 import { evaluateRouteGuards, findSystemFeature } from "../route-guards.js";
 import type { createServerRuntime } from "../runtime.js";

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

@@ -2,7 +2,7 @@ import {
   DEFAULT_PAGE_SIZE,
   MAX_PAGE_SIZE,
   type PageRequest,
-} from "@windy/shared";
+} from "@southwind-ai/shared";
 
 export function parsePagination(query: {
   page?: string;

package/template/apps/server/src/persistence.integration.test.ts

@@ -1,5 +1,5 @@
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
-import type { AuditEvent } from "@windy/shared";
+import type { AuditEvent } from "@southwind-ai/shared";
 import { resolve } from "node:path";
 import { drizzle } from "drizzle-orm/node-postgres";
 import { migrate } from "drizzle-orm/node-postgres/migrator";

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

@@ -1,4 +1,4 @@
-import type { PlatformConfig } from "@windy/config";
+import type { PlatformConfig } from "@southwind-ai/config";
 import { drizzle, type NodePgDatabase } from "drizzle-orm/node-postgres";
 import { Pool } from "pg";
 import type { AuditWriteStatus } from "./audit/contracts.js";

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

@@ -3,7 +3,7 @@ import type {
   FeatureFlagDefinition,
   UserProfile,
   UserProfileUpdate,
-} from "@windy/shared";
+} from "@southwind-ai/shared";
 import { recordMutationAudit } from "../audit/policy.js";
 import type { AuthRepository, AuthUserRecord } from "../auth/repository.js";
 import { evaluateRouteGuards, findFeature } from "../route-guards.js";

package/template/apps/server/src/route-guards.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { entitlementKey, featureKey } from "@windy/shared";
+import { entitlementKey, featureKey } from "@southwind-ai/shared";
 import { evaluateAccessGuards } from "./access-guards.js";
 import { createServerRuntime } from "./runtime.js";
 

package/template/apps/server/src/route-guards.ts

@@ -1,7 +1,7 @@
 import type {
   ApiPermissionBinding,
   FeatureFlagDefinition,
-} from "@windy/shared";
+} from "@southwind-ai/shared";
 import { evaluateAccessGuards } from "./access-guards.js";
 import type { GuardDecision, RequestGuardContext } from "./guards.js";
 import type { createServerRuntime } from "./runtime.js";

package/template/apps/server/src/runtime-feature.ts

@@ -0,0 +1,125 @@
+import type { FeatureFlagDefinition } from "@southwind-ai/shared";
+
+export interface FeatureFlagRuntimeResolver {
+  resolve(
+    key: string,
+  ):
+    | Promise<FeatureFlagRuntimeState | undefined>
+    | FeatureFlagRuntimeState
+    | undefined;
+}
+
+export interface FeatureFlagRuntimeState {
+  key: string;
+  enabled: boolean;
+  visible: FeatureFlagDefinition["visible"];
+  allowedLicenseVersions?: FeatureFlagDefinition["allowedLicenseVersions"];
+}
+
+export class RuntimeFeatureCatalog {
+  private readonly definitions = new Map<string, FeatureFlagDefinition>();
+  private readonly requestCache = new WeakMap<
+    object,
+    Map<string, FeatureFlagDefinition>
+  >();
+
+  constructor(
+    definitions: readonly FeatureFlagDefinition[],
+    private readonly resolver: FeatureFlagRuntimeResolver | undefined,
+    private readonly production: boolean,
+  ) {
+    for (const definition of definitions) {
+      this.definitions.set(definition.key, definition);
+    }
+  }
+
+  resolve(
+    context: object,
+    manifestFeature: FeatureFlagDefinition,
+  ): Promise<FeatureFlagDefinition> {
+    this.definitions.set(manifestFeature.key, manifestFeature);
+    return this.resolveInternal(context, manifestFeature, new Set());
+  }
+
+  private async resolveInternal(
+    context: object,
+    manifestFeature: FeatureFlagDefinition,
+    visiting: ReadonlySet<string>,
+  ): Promise<FeatureFlagDefinition> {
+    const cache = this.cacheFor(context);
+    const cached = cache.get(manifestFeature.key);
+    if (cached) return cached;
+    if (visiting.has(manifestFeature.key)) {
+      return disabledFeature(manifestFeature);
+    }
+
+    const resolved = await this.resolveOwnState(manifestFeature);
+    if (!resolved.enabled || !manifestFeature.dependencies?.length) {
+      cache.set(manifestFeature.key, resolved);
+      return resolved;
+    }
+
+    const nextVisiting = new Set(visiting);
+    nextVisiting.add(manifestFeature.key);
+    for (const dependencyKey of manifestFeature.dependencies) {
+      const dependency = this.definitions.get(dependencyKey);
+      if (!dependency) {
+        const disabled = disabledFeature(resolved);
+        cache.set(manifestFeature.key, disabled);
+        return disabled;
+      }
+      const dependencyState = await this.resolveInternal(
+        context,
+        dependency,
+        nextVisiting,
+      );
+      if (!dependencyState.enabled || dependencyState.visible !== "visible") {
+        const disabled = { ...resolved, enabled: false };
+        cache.set(manifestFeature.key, disabled);
+        return disabled;
+      }
+    }
+
+    cache.set(manifestFeature.key, resolved);
+    return resolved;
+  }
+
+  private async resolveOwnState(
+    manifestFeature: FeatureFlagDefinition,
+  ): Promise<FeatureFlagDefinition> {
+    if (!this.resolver) {
+      return this.production
+        ? disabledFeature(manifestFeature)
+        : manifestFeature;
+    }
+    try {
+      const state = await this.resolver.resolve(manifestFeature.key);
+      if (!state) return disabledFeature(manifestFeature);
+      return {
+        ...manifestFeature,
+        enabled: state.enabled,
+        visible: state.visible,
+        ...(Object.hasOwn(state, "allowedLicenseVersions")
+          ? { allowedLicenseVersions: state.allowedLicenseVersions }
+          : {}),
+      };
+    } catch {
+      return disabledFeature(manifestFeature);
+    }
+  }
+
+  private cacheFor(context: object): Map<string, FeatureFlagDefinition> {
+    let cache = this.requestCache.get(context);
+    if (!cache) {
+      cache = new Map();
+      this.requestCache.set(context, cache);
+    }
+    return cache;
+  }
+}
+
+function disabledFeature(
+  feature: FeatureFlagDefinition,
+): FeatureFlagDefinition {
+  return { ...feature, enabled: false, visible: "hidden" };
+}

package/template/apps/server/src/runtime-license.ts

@@ -2,7 +2,7 @@ import {
   licenseVersionKey,
   type EntitlementKey,
   type LicenseVersionKey,
-} from "@windy/shared";
+} from "@southwind-ai/shared";
 
 export interface LicenseEntitlementState {
   versionKey?: LicenseVersionKey;

package/template/apps/server/src/runtime.test.ts

@@ -1,6 +1,11 @@
 import { randomUUIDv7 } from "bun";
 import { describe, expect, test } from "bun:test";
-import { entitlementKey, type AuditEvent } from "@windy/shared";
+import {
+  entitlementKey,
+  featureKey,
+  type AuditEvent,
+  type FeatureFlagDefinition,
+} from "@southwind-ai/shared";
 import { createFoundationSnapshot } from "./foundation.js";
 import { createServerRuntime } from "./runtime.js";
 import { AuditWriteUnavailableError } from "./audit/contracts.js";
@@ -240,6 +245,37 @@ describe("server runtime", () => {
     });
   });
 
+  test("Feature 依赖在运行时实际 fail closed", async () => {
+    const dependency = runtimeFeature("business.base");
+    const capability = {
+      ...runtimeFeature("business.report"),
+      dependencies: [dependency.key],
+    };
+    const runtime = createServerRuntime(
+      {},
+      {
+        featureCatalog: [dependency, capability],
+        featureResolver: {
+          resolve(key) {
+            return {
+              key,
+              enabled: key !== dependency.key,
+              visible: "visible",
+            };
+          },
+        },
+      },
+    );
+    const context = await runtime.createGuardContext(
+      new Request("http://localhost/api/business/report"),
+    );
+
+    expect(await runtime.resolveFeature(context, capability)).toMatchObject({
+      enabled: false,
+      visible: "visible",
+    });
+  });
+
   test("数据库运行态读取失败时 fail closed", async () => {
     const manifest = createFoundationSnapshot().features[0]!;
     const runtime = createServerRuntime(
@@ -262,3 +298,14 @@ describe("server runtime", () => {
     });
   });
 });
+
+function runtimeFeature(key: string): FeatureFlagDefinition {
+  return {
+    key: featureKey(key),
+    label: key,
+    module: "business",
+    visible: "visible",
+    enabled: true,
+    stage: "stable",
+  };
+}