create-windy 0.2.34 → 0.3.1

package/template/apps/server/src/system/department-routes.ts

@@ -6,6 +6,11 @@ import type { ManagedDepartment } from "./entities.js";
 import { forbidden, resourceEvent, routeContext } from "./route-helpers.js";
 import type { EntityRepository } from "./repository.js";
 import type { RouteApp } from "./route-types.js";
+import type { MutationRunner } from "./mutation-runner.js";
+import {
+  DepartmentOrganizationPolicy,
+  type DepartmentTransitionAction,
+} from "./department-organization.js";
 
 type ServerRuntime = ReturnType<typeof createServerRuntime>;
 
@@ -14,6 +19,8 @@ export function registerDepartmentQuickCreateRoute(
   departments: EntityRepository<ManagedDepartment>,
   runtime: ServerRuntime,
   feature?: FeatureFlagDefinition,
+  policy?: DepartmentOrganizationPolicy,
+  mutationRunner?: MutationRunner,
 ): void {
   app.post("/system/departments/quick", async (rawContext) => {
     const { guardContext, body } = routeContext(rawContext);
@@ -28,36 +35,22 @@ export function registerDepartmentQuickCreateRoute(
     if (!decision.allowed) return forbidden(decision.reason);
     const parsed = parseDepartment(body);
     if (parsed instanceof Response) return parsed;
-    const duplicate = (await departments.all()).find(
-      (department) => department.code === parsed.code,
-    );
-    if (duplicate) {
-      return Response.json(
-        { error: "DUPLICATE_DEPARTMENT_CODE", message: "部门编码已存在" },
-        { status: 409 },
-      );
-    }
-    if (parsed.parentId) {
-      const parent = await departments.get(parsed.parentId);
-      if (!parent || parent.status !== "active") {
-        return Response.json(
-          {
-            error: "INVALID_DEPARTMENT_PARENT",
-            message: "上级部门不存在或已停用",
-          },
-          { status: 400 },
-        );
+    const create = async () => {
+      const policyError = await policy?.beforeCreate(parsed);
+      if (policyError) {
+        return Response.json(policyError, { status: 409 });
       }
-    }
-    const item = await departments.create(parsed, guardContext.actor);
-    await recordMutationAudit(
-      runtime,
-      "departments",
-      resourceEvent(guardContext, "crud.create", "departments", item.id, {
-        source: "user-form-shortcut",
-      }),
-    );
-    return item;
+      const item = await departments.create(parsed, guardContext.actor);
+      await recordMutationAudit(
+        runtime,
+        "departments",
+        resourceEvent(guardContext, "crud.create", "departments", item.id, {
+          source: "user-form-shortcut",
+        }),
+      );
+      return item;
+    };
+    return mutationRunner ? mutationRunner.run(create) : create();
   });
 }
 
@@ -75,16 +68,104 @@ function parseDepartment(body: unknown): Partial<ManagedDepartment> | Response {
       { status: 400 },
     );
   }
+  const parentId =
+    typeof value.parentId === "string" && value.parentId
+      ? value.parentId
+      : undefined;
+  if (!parentId) {
+    return Response.json(
+      {
+        error: "DEPARTMENT_PARENT_REQUIRED",
+        message: "平台只允许一个根组织，新部门必须选择上级部门",
+      },
+      { status: 400 },
+    );
+  }
   return {
     code,
     name,
-    parentId:
-      typeof value.parentId === "string" && value.parentId
-        ? value.parentId
-        : undefined,
+    parentId,
     order:
       typeof value.order === "number" && Number.isFinite(value.order)
         ? value.order
         : 100,
   };
 }
+
+export function registerDepartmentTransitionRoute(
+  app: RouteApp,
+  policy: DepartmentOrganizationPolicy,
+  mutationRunner: MutationRunner,
+  runtime: ServerRuntime,
+  feature?: FeatureFlagDefinition,
+): void {
+  app.post("/system/departments/:id/transition", async (rawContext) => {
+    const { guardContext, params, body } = routeContext(rawContext);
+    const decision = await evaluateRouteGuards(runtime, guardContext, {
+      permission: {
+        method: "POST",
+        path: "/api/system/departments/:id/transition",
+        permissionKey: "system.department.manage",
+      },
+      feature,
+    });
+    if (!decision.allowed) return forbidden(decision.reason);
+    const parsed = parseTransition(body);
+    if (parsed instanceof Response) return parsed;
+    return mutationRunner.run(async () => {
+      const result = await policy.transition(
+        String(params.id || ""),
+        parsed.action,
+        parsed.targetDepartmentId,
+        guardContext.actor,
+      );
+      if ("error" in result) {
+        return Response.json(result, { status: 409 });
+      }
+      await recordMutationAudit(
+        runtime,
+        "departments",
+        resourceEvent(
+          guardContext,
+          "organization.department.transition",
+          "departments",
+          result.department.id,
+          {
+            action: parsed.action,
+            targetDepartmentId: parsed.targetDepartmentId,
+            movedChildren: result.movedChildren,
+            movedUsers: result.movedUsers,
+            updatedRoles: result.updatedRoles,
+          },
+        ),
+      );
+      return result;
+    });
+  });
+}
+
+function parseTransition(body: unknown):
+  | {
+      action: DepartmentTransitionAction;
+      targetDepartmentId?: string;
+    }
+  | Response {
+  const value =
+    body && typeof body === "object" ? (body as Record<string, unknown>) : {};
+  if (value.action !== "disable" && value.action !== "delete") {
+    return Response.json(
+      {
+        error: "INVALID_DEPARTMENT_TRANSITION",
+        message: "部门处置动作只能是 disable 或 delete",
+      },
+      { status: 400 },
+    );
+  }
+  return {
+    action: value.action,
+    targetDepartmentId:
+      typeof value.targetDepartmentId === "string" && value.targetDepartmentId
+        ? value.targetDepartmentId
+        : undefined,
+  };
+}

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

@@ -21,6 +21,7 @@ import type {
   EntityListQuery,
   EntityRepository,
 } from "./repository.js";
+import { DrizzleTransactionContext } from "./drizzle-transaction-context.js";
 
 type DbTable = unknown;
 
@@ -40,6 +41,7 @@ export class DrizzleEntityRepository<
   constructor(
     protected readonly db: NodePgDatabase,
     protected readonly config: DrizzleEntityRepositoryConfig<T>,
+    private readonly transactionContext?: DrizzleTransactionContext,
   ) {}
 
   async list(
@@ -99,7 +101,9 @@ export class DrizzleEntityRepository<
       updatedAt: now,
       updatedBy: actor.id,
     } as T;
-    await this.db.insert(this.table()).values(this.config.toRow(entity));
+    await this.database()
+      .insert(this.table())
+      .values(this.config.toRow(entity));
     return entity;
   }
 
@@ -119,7 +123,7 @@ export class DrizzleEntityRepository<
       updatedAt: new Date().toISOString(),
       updatedBy: actor.id,
     } as T;
-    await this.db
+    await this.database()
       .update(this.table())
       .set(this.config.toRow(entity))
       .where(eq(this.idColumn(), id));
@@ -133,7 +137,7 @@ export class DrizzleEntityRepository<
     if (updates.length === 0) return [];
     await this.ensureSeeded();
     const ids = updates.map(({ id }) => id);
-    const rows = await this.db
+    const rows = await this.database()
       .select()
       .from(this.table())
       .where(inArray(this.idColumn(), ids));
@@ -154,7 +158,7 @@ export class DrizzleEntityRepository<
       updatedAt: now,
       updatedBy: actor.id,
     })) as T[];
-    await this.db.transaction(async (transaction) => {
+    await this.database().transaction(async (transaction) => {
       for (const entity of entities) {
         await transaction
           .update(this.table())
@@ -221,7 +225,7 @@ export class DrizzleEntityRepository<
     if (items.length === 0) {
       return;
     }
-    await this.db
+    await this.database()
       .insert(this.table())
       .values(items.map((item) => this.config.toRow(item)))
       .onConflictDoNothing();
@@ -255,7 +259,7 @@ export class DrizzleEntityRepository<
     offset?: number,
   ) {
     const orderBy = this.orderBy(sort);
-    let query = this.db.select().from(this.table()).$dynamic();
+    let query = this.database().select().from(this.table()).$dynamic();
     if (where) query = query.where(where);
     if (orderBy.length) query = query.orderBy(...orderBy);
     if (limit) query = query.limit(limit);
@@ -266,7 +270,7 @@ export class DrizzleEntityRepository<
   protected countRows(
     where: SQL | undefined,
   ): Promise<Array<{ count: number }>> {
-    let query = this.db
+    let query = this.database()
       .select({ count: sql<number>`count(*)::int` })
       .from(this.table())
       .$dynamic();
@@ -295,4 +299,8 @@ export class DrizzleEntityRepository<
   protected table() {
     return this.config.table as never;
   }
+
+  protected database(): NodePgDatabase {
+    return this.transactionContext?.current(this.db) || this.db;
+  }
 }

package/template/apps/server/src/system/drizzle-scoped-repository.ts

@@ -19,6 +19,7 @@ import {
   type DrizzleEntityRepositoryConfig,
 } from "./drizzle-repository.js";
 import type { EntityImportResult, EntityListQuery } from "./repository.js";
+import type { DrizzleTransactionContext } from "./drizzle-transaction-context.js";
 
 export interface DrizzleScopedEntityRepositoryConfig<
   T extends ManagedEntity,
@@ -38,8 +39,9 @@ export class DrizzleScopedEntityRepository<T extends ManagedEntity>
   constructor(
     db: NodePgDatabase,
     config: DrizzleScopedEntityRepositoryConfig<T>,
+    transactionContext?: DrizzleTransactionContext,
   ) {
-    super(db, config);
+    super(db, config, transactionContext);
   }
 
   async listScoped(
@@ -98,7 +100,7 @@ export class DrizzleScopedEntityRepository<T extends ManagedEntity>
   ): Promise<T[] | undefined> {
     if (ids.length === 0) return [];
     await this.ensureSeeded();
-    return this.db.transaction(
+    return this.database().transaction(
       async (transaction) => {
         await transaction.execute(sql`select 1`);
         await this.afterBatchSnapshotEstablished();
@@ -157,7 +159,7 @@ export class DrizzleScopedEntityRepository<T extends ManagedEntity>
       updatedBy: actor.id,
     } as T;
     assertEntityInDataScope(entity, scope, this.config.dataScope.entity);
-    const rows = (await this.db
+    const rows = (await this.database()
       .update(this.table())
       .set(this.config.toRow(entity))
       .where(this.idWhere(id, scope))

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