create-windy 0.1.0

package/template/packages/database/drizzle/meta/_journal.json

@@ -0,0 +1,223 @@
+{
+  "version": "7",
+  "dialect": "postgresql",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "7",
+      "when": 1783583280985,
+      "tag": "0000_organic_madame_web",
+      "breakpoints": true
+    },
+    {
+      "idx": 1,
+      "version": "7",
+      "when": 1783616576561,
+      "tag": "0001_flawless_senator_kelly",
+      "breakpoints": true
+    },
+    {
+      "idx": 2,
+      "version": "7",
+      "when": 1783618548704,
+      "tag": "0002_woozy_squadron_supreme",
+      "breakpoints": true
+    },
+    {
+      "idx": 3,
+      "version": "7",
+      "when": 1783620366865,
+      "tag": "0003_far_carnage",
+      "breakpoints": true
+    },
+    {
+      "idx": 4,
+      "version": "7",
+      "when": 1783620628849,
+      "tag": "0004_flat_bastion",
+      "breakpoints": true
+    },
+    {
+      "idx": 5,
+      "version": "7",
+      "when": 1783621326518,
+      "tag": "0005_fixed_enchantress",
+      "breakpoints": true
+    },
+    {
+      "idx": 6,
+      "version": "7",
+      "when": 1783669107988,
+      "tag": "0006_groovy_overlord",
+      "breakpoints": true
+    },
+    {
+      "idx": 7,
+      "version": "7",
+      "when": 1783670238749,
+      "tag": "0007_chubby_may_parker",
+      "breakpoints": true
+    },
+    {
+      "idx": 8,
+      "version": "7",
+      "when": 1783671493704,
+      "tag": "0008_secret_toxin",
+      "breakpoints": true
+    },
+    {
+      "idx": 9,
+      "version": "7",
+      "when": 1783675123015,
+      "tag": "0009_ambiguous_adam_warlock",
+      "breakpoints": true
+    },
+    {
+      "idx": 10,
+      "version": "7",
+      "when": 1783676018415,
+      "tag": "0010_complex_orphan",
+      "breakpoints": true
+    },
+    {
+      "idx": 11,
+      "version": "7",
+      "when": 1783676761870,
+      "tag": "0011_lowly_maria_hill",
+      "breakpoints": true
+    },
+    {
+      "idx": 12,
+      "version": "7",
+      "when": 1784020942140,
+      "tag": "0012_serious_marvex",
+      "breakpoints": true
+    },
+    {
+      "idx": 13,
+      "version": "7",
+      "when": 1784023384433,
+      "tag": "0013_mysterious_miek",
+      "breakpoints": true
+    },
+    {
+      "idx": 14,
+      "version": "7",
+      "when": 1784039782061,
+      "tag": "0014_graceful_husk",
+      "breakpoints": true
+    },
+    {
+      "idx": 15,
+      "version": "7",
+      "when": 1784041383233,
+      "tag": "0015_illegal_jazinda",
+      "breakpoints": true
+    },
+    {
+      "idx": 16,
+      "version": "7",
+      "when": 1784046471538,
+      "tag": "0016_seed_platform_roles",
+      "breakpoints": true
+    },
+    {
+      "idx": 17,
+      "version": "7",
+      "when": 1784049986391,
+      "tag": "0017_silly_thunderbolt",
+      "breakpoints": true
+    },
+    {
+      "idx": 18,
+      "version": "7",
+      "when": 1784052998662,
+      "tag": "0018_cheerful_alex_power",
+      "breakpoints": true
+    },
+    {
+      "idx": 19,
+      "version": "7",
+      "when": 1784143907768,
+      "tag": "0019_omniscient_luckman",
+      "breakpoints": true
+    },
+    {
+      "idx": 20,
+      "version": "7",
+      "when": 1784147050168,
+      "tag": "0020_handy_vertigo",
+      "breakpoints": true
+    },
+    {
+      "idx": 21,
+      "version": "7",
+      "when": 1784148379839,
+      "tag": "0021_plain_paladin",
+      "breakpoints": true
+    },
+    {
+      "idx": 22,
+      "version": "7",
+      "when": 1784148405988,
+      "tag": "0022_icy_rhodey",
+      "breakpoints": true
+    },
+    {
+      "idx": 23,
+      "version": "7",
+      "when": 1784148428241,
+      "tag": "0023_fresh_thunderbolt_ross",
+      "breakpoints": true
+    },
+    {
+      "idx": 24,
+      "version": "7",
+      "when": 1784148444997,
+      "tag": "0024_misty_lizard",
+      "breakpoints": true
+    },
+    {
+      "idx": 25,
+      "version": "7",
+      "when": 1784148483062,
+      "tag": "0025_premium_songbird",
+      "breakpoints": true
+    },
+    {
+      "idx": 26,
+      "version": "7",
+      "when": 1784151611693,
+      "tag": "0026_aberrant_doctor_octopus",
+      "breakpoints": true
+    },
+    {
+      "idx": 27,
+      "version": "7",
+      "when": 1784151765459,
+      "tag": "0027_tiny_diamondback",
+      "breakpoints": true
+    },
+    {
+      "idx": 28,
+      "version": "7",
+      "when": 1784154269590,
+      "tag": "0028_condemned_ulik",
+      "breakpoints": true
+    },
+    {
+      "idx": 29,
+      "version": "7",
+      "when": 1784158492836,
+      "tag": "0029_clean_nightshade",
+      "breakpoints": true
+    },
+    {
+      "idx": 30,
+      "version": "7",
+      "when": 1784160403893,
+      "tag": "0030_governed_export_constraints",
+      "breakpoints": true
+    }
+  ]
+}

package/template/packages/database/index.ts

@@ -0,0 +1,5 @@
+export * from "./src/dialects.js";
+export * from "./src/runner.js";
+export * from "./src/schema/index.js";
+export * from "./src/sql-store.js";
+export * from "./src/store.js";

package/template/packages/database/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@windy/database",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "typecheck": "tsc --noEmit --project tsconfig.json"
+  },
+  "dependencies": {
+    "@windy/modules": "workspace:*",
+    "@windy/shared": "workspace:*",
+    "drizzle-orm": "^0.45.2"
+  },
+  "exports": {
+    ".": "./index.ts"
+  }
+}

package/template/packages/database/src/dialects.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, test } from "bun:test";
+import { createDialectAdapter } from "./dialects.js";
+
+describe("createDialectAdapter", () => {
+  test("按方言映射保留字和 JSON 路径", () => {
+    const postgres = createDialectAdapter("postgresql");
+    const mysql = createDialectAdapter("mysql");
+    const dm = createDialectAdapter("dm");
+
+    expect(postgres.mapIdentifier("user")).toBe('"user"');
+    expect(mysql.mapIdentifier("user")).toBe("`user`");
+    expect(postgres.mapJsonPath("payload", ["profile", "name"])).toBe(
+      "payload #>> '{profile,name}'",
+    );
+    expect(mysql.mapJsonPath("payload", ["profile", "name"])).toBe(
+      "json_extract(payload, '$.profile.name')",
+    );
+    expect(dm.mapJsonPath("payload", ["profile", "name"])).toBe("payload");
+  });
+
+  test("分页和逻辑类型映射保持 canonical 输入", () => {
+    const kingbase = createDialectAdapter("kingbase");
+
+    expect(kingbase.mapPagination({ page: 3, pageSize: 20 })).toEqual({
+      limit: 20,
+      offset: 40,
+    });
+    expect(kingbase.mapColumnType("json")).toEqual({
+      logicalType: "json",
+      physicalType: "json",
+    });
+  });
+});

package/template/packages/database/src/dialects.ts

@@ -0,0 +1,139 @@
+import type {
+  ColumnTypeMapping,
+  DatabaseCompatibilityAdapter,
+  DatabaseDialect,
+  DialectCapabilities,
+  PageRequest,
+  PaginationSqlParts,
+} from "@windy/shared";
+
+const reservedWords: Record<DatabaseDialect, string[]> = {
+  postgresql: ["user", "role", "order"],
+  mysql: ["user", "role", "order"],
+  dm: ["user", "role", "order", "limit"],
+  kingbase: ["user", "role", "order", "limit"],
+};
+
+const capabilities: Record<DatabaseDialect, DialectCapabilities> = {
+  postgresql: {
+    dialect: "postgresql",
+    identifierStrategy: "identity",
+    jsonColumnStrategy: "jsonb",
+    supportsReturning: true,
+    supportsRecursiveCte: true,
+    supportsFullTextSearch: true,
+    reservedWords: reservedWords.postgresql,
+  },
+  mysql: {
+    dialect: "mysql",
+    identifierStrategy: "auto-increment",
+    jsonColumnStrategy: "json",
+    supportsReturning: false,
+    supportsRecursiveCte: true,
+    supportsFullTextSearch: true,
+    reservedWords: reservedWords.mysql,
+  },
+  dm: {
+    dialect: "dm",
+    identifierStrategy: "sequence",
+    jsonColumnStrategy: "text",
+    supportsReturning: false,
+    supportsRecursiveCte: true,
+    supportsFullTextSearch: false,
+    reservedWords: reservedWords.dm,
+  },
+  kingbase: {
+    dialect: "kingbase",
+    identifierStrategy: "identity",
+    jsonColumnStrategy: "json",
+    supportsReturning: true,
+    supportsRecursiveCte: true,
+    supportsFullTextSearch: false,
+    reservedWords: reservedWords.kingbase,
+  },
+};
+
+const typeMappings: Record<
+  DatabaseDialect,
+  Record<ColumnTypeMapping["logicalType"], string>
+> = {
+  postgresql: {
+    id: "uuid",
+    string: "varchar(255)",
+    text: "text",
+    integer: "integer",
+    boolean: "boolean",
+    datetime: "timestamptz",
+    json: "jsonb",
+  },
+  mysql: {
+    id: "varchar(36)",
+    string: "varchar(255)",
+    text: "text",
+    integer: "int",
+    boolean: "tinyint(1)",
+    datetime: "datetime",
+    json: "json",
+  },
+  dm: {
+    id: "varchar(36)",
+    string: "varchar(255)",
+    text: "clob",
+    integer: "int",
+    boolean: "tinyint",
+    datetime: "timestamp",
+    json: "clob",
+  },
+  kingbase: {
+    id: "varchar(36)",
+    string: "varchar(255)",
+    text: "text",
+    integer: "integer",
+    boolean: "boolean",
+    datetime: "timestamp",
+    json: "json",
+  },
+};
+
+export function createDialectAdapter(
+  dialect: DatabaseDialect,
+): DatabaseCompatibilityAdapter {
+  return {
+    dialect,
+    capabilities: capabilities[dialect],
+    mapColumnType(logicalType) {
+      return {
+        logicalType,
+        physicalType: typeMappings[dialect][logicalType],
+      };
+    },
+    mapIdentifier(name) {
+      const needsQuote = capabilities[dialect].reservedWords.includes(
+        name.toLowerCase(),
+      );
+      if (!needsQuote) {
+        return name;
+      }
+
+      return dialect === "mysql" ? `\`${name}\`` : `"${name}"`;
+    },
+    mapJsonPath(column, path) {
+      const jsonPath = path.join(".");
+      if (dialect === "postgresql") {
+        return `${column} #>> '{${path.join(",")}}'`;
+      }
+
+      if (dialect === "mysql" || dialect === "kingbase") {
+        return `json_extract(${column}, '$.${jsonPath}')`;
+      }
+
+      return `${column}`;
+    },
+    mapPagination(request: PageRequest): PaginationSqlParts {
+      return {
+        limit: request.pageSize,
+        offset: (request.page - 1) * request.pageSize,
+      };
+    },
+  };
+}

package/template/packages/database/src/runner.test.ts

@@ -0,0 +1,96 @@
+import { describe, expect, test } from "bun:test";
+import type { ModuleManifest } from "@windy/modules";
+import { PlatformMigrationRunner } from "./runner.js";
+import { InMemoryMigrationHistoryStore } from "./store.js";
+
+function moduleFixture(
+  name: string,
+  dependencies: string[] = [],
+): ModuleManifest {
+  return {
+    name,
+    version: "0.1.0",
+    label: name,
+    description: `${name} module`,
+    dependencies,
+    menus: [],
+    adminRoutes: [],
+    permissions: [],
+    apiPermissions: [],
+    features: [],
+    migrations: [
+      {
+        id: `${name}.001`,
+        module: name,
+        description: "create table",
+        direction: "up",
+        async run(context) {
+          await context.execute({
+            sql: `create table ${context.adapter.mapIdentifier(name)} (id varchar(36))`,
+          });
+        },
+      },
+    ],
+    schemaExports: [],
+    tasks: [],
+    tools: [],
+    providers: [],
+    auditActions: [],
+  };
+}
+
+describe("PlatformMigrationRunner", () => {
+  test("按模块依赖顺序 dry-run，并不执行真实 SQL", async () => {
+    const executed: string[] = [];
+    const runner = new PlatformMigrationRunner({
+      dialect: "postgresql",
+      store: new InMemoryMigrationHistoryStore(),
+      execute: async (statement) => {
+        executed.push(statement.sql);
+      },
+    });
+
+    const report = await runner.run(
+      [moduleFixture("feature", ["system"]), moduleFixture("system")],
+      true,
+    );
+
+    expect(report.applied).toEqual(["system.001", "feature.001"]);
+    expect(report.statements.map((statement) => statement.sql)).toEqual([
+      "create table system (id varchar(36))",
+      "create table feature (id varchar(36))",
+    ]);
+    expect(executed).toEqual([]);
+  });
+
+  test("已执行迁移会跳过，非 dry-run 会调用执行器", async () => {
+    const store = new InMemoryMigrationHistoryStore();
+    await store.record({
+      id: "system.001",
+      module: "system",
+      direction: "up",
+      status: "applied",
+      startedAt: "2026-07-09T00:00:00.000Z",
+      finishedAt: "2026-07-09T00:00:00.000Z",
+    });
+    const executed: string[] = [];
+    const runner = new PlatformMigrationRunner({
+      dialect: "mysql",
+      store,
+      execute: async (statement) => {
+        executed.push(statement.sql);
+      },
+    });
+
+    const report = await runner.run([
+      moduleFixture("system"),
+      moduleFixture("audit"),
+    ]);
+
+    expect(
+      report.planned.find((item) => item.id === "system.001")?.skipped,
+    ).toBe(true);
+    expect(report.applied).toEqual(["audit.001"]);
+    expect(executed).toEqual(["create table audit (id varchar(36))"]);
+  });
+});

package/template/packages/database/src/runner.ts

@@ -0,0 +1,175 @@
+import type { MigrationDefinition, ModuleManifest } from "@windy/modules";
+import type {
+  DatabaseCompatibilityAdapter,
+  DatabaseDialect,
+  MigrationStatement,
+} from "@windy/shared";
+import { createDialectAdapter } from "./dialects.js";
+import type { MigrationHistoryStore } from "./store.js";
+
+export interface MigrationRunnerOptions {
+  dialect: DatabaseDialect;
+  store: MigrationHistoryStore;
+  execute?: (statement: MigrationStatement) => Promise<void>;
+  now?: () => Date;
+}
+
+export interface MigrationPlanItem {
+  id: string;
+  module: string;
+  description: string;
+  direction: "up" | "down";
+  skipped: boolean;
+  skipReason?: string;
+}
+
+export interface MigrationRunReport {
+  dialect: DatabaseDialect;
+  dryRun: boolean;
+  startedAt: string;
+  finishedAt: string;
+  planned: MigrationPlanItem[];
+  applied: string[];
+  failed: Array<{ id: string; error: string }>;
+  statements: MigrationStatement[];
+}
+
+export class PlatformMigrationRunner {
+  private readonly adapter: DatabaseCompatibilityAdapter;
+  private readonly executeStatement: (
+    statement: MigrationStatement,
+  ) => Promise<void>;
+  private readonly now: () => Date;
+
+  constructor(private readonly options: MigrationRunnerOptions) {
+    this.adapter = createDialectAdapter(options.dialect);
+    this.executeStatement = options.execute || (async () => undefined);
+    this.now = options.now || (() => new Date());
+  }
+
+  async plan(modules: ModuleManifest[]): Promise<MigrationPlanItem[]> {
+    const appliedIds = new Set(
+      (await this.options.store.listApplied()).map((entry) => entry.id),
+    );
+
+    return sortModulesByDependency(modules).flatMap((module) =>
+      module.migrations.map((migration) => ({
+        id: migration.id,
+        module: migration.module,
+        description: migration.description,
+        direction: migration.direction,
+        skipped: appliedIds.has(migration.id),
+        skipReason: appliedIds.has(migration.id)
+          ? "already-applied"
+          : undefined,
+      })),
+    );
+  }
+
+  async run(
+    modules: ModuleManifest[],
+    dryRun = false,
+  ): Promise<MigrationRunReport> {
+    const startedAt = this.now().toISOString();
+    const planned = await this.plan(modules);
+    const migrations = collectMigrations(modules);
+    const applied: string[] = [];
+    const failed: Array<{ id: string; error: string }> = [];
+    const statements: MigrationStatement[] = [];
+
+    for (const item of planned) {
+      if (item.skipped) {
+        continue;
+      }
+
+      const migration = migrations.get(item.id);
+      if (!migration) {
+        continue;
+      }
+
+      const stepStartedAt = this.now().toISOString();
+      const stepStatements: MigrationStatement[] = [];
+      try {
+        await migration.run({
+          dialect: this.options.dialect,
+          dryRun,
+          adapter: this.adapter,
+          execute: async (statement) => {
+            statements.push(statement);
+            stepStatements.push(statement);
+            if (!dryRun) {
+              await this.executeStatement(statement);
+            }
+          },
+        });
+        applied.push(item.id);
+        await this.options.store.record({
+          id: item.id,
+          module: item.module,
+          direction: item.direction,
+          status: "applied",
+          startedAt: stepStartedAt,
+          finishedAt: this.now().toISOString(),
+          statements: stepStatements.map((statement) => statement.sql),
+        });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        failed.push({ id: item.id, error: message });
+        await this.options.store.record({
+          id: item.id,
+          module: item.module,
+          direction: item.direction,
+          status: "failed",
+          startedAt: stepStartedAt,
+          finishedAt: this.now().toISOString(),
+          statements: stepStatements.map((statement) => statement.sql),
+          error: message,
+        });
+        break;
+      }
+    }
+
+    return {
+      dialect: this.options.dialect,
+      dryRun,
+      startedAt,
+      finishedAt: this.now().toISOString(),
+      planned,
+      applied,
+      failed,
+      statements,
+    };
+  }
+}
+
+function collectMigrations(
+  modules: ModuleManifest[],
+): Map<string, MigrationDefinition> {
+  return new Map(
+    modules
+      .flatMap((module) => module.migrations)
+      .map((migration) => [migration.id, migration]),
+  );
+}
+
+function sortModulesByDependency(modules: ModuleManifest[]): ModuleManifest[] {
+  const pending = new Map(modules.map((module) => [module.name, module]));
+  const sorted: ModuleManifest[] = [];
+
+  while (pending.size > 0) {
+    const ready = Array.from(pending.values()).find((module) =>
+      (module.dependencies || []).every(
+        (dependency) => !pending.has(dependency),
+      ),
+    );
+
+    if (!ready) {
+      throw new Error("模块依赖存在循环，无法生成迁移计划");
+    }
+
+    sorted.push(ready);
+    pending.delete(ready.name);
+  }
+
+  return sorted;
+}