create-windy 0.1.0

package/template/packages/crud-generator/src/templates/index.ts

@@ -0,0 +1,8 @@
+export { domainTemplate } from "./domain.js";
+export { drizzleRepositoryTemplate } from "./drizzle-repository.js";
+export { dtoTemplate } from "./dto.js";
+export { manifestTemplate } from "./manifest.js";
+export { repositoryTemplate } from "./repository.js";
+export { routesTemplate } from "./routes.js";
+export { schemaTemplate } from "./schema.js";
+export { serviceTemplate } from "./service.js";

package/template/packages/crud-generator/src/templates/manifest.ts

@@ -0,0 +1,69 @@
+import type { CrudModuleDefinition } from "../definition.js";
+import { fieldPermission, quote } from "../template-helpers.js";
+
+export function manifestTemplate(definition: CrudModuleDefinition): string {
+  const { entity, module } = definition;
+  const actions = ["read", "create", "update", "delete"] as const;
+  const licenseVersions = entity.allowedLicenseVersions?.length
+    ? `allowedLicenseVersions: [${entity.allowedLicenseVersions.map((key) => `licenseVersionKey(${quote(key)})`).join(", ")}],`
+    : "";
+  return `import type { ModuleManifest } from "@windy/modules";
+import { featureKey, licenseVersionKey } from "@windy/shared";
+
+export function ${module.name.replace(/[-.]/g, "_")}Module(): ModuleManifest {
+  return {
+    name: ${quote(module.name)},
+    version: ${quote(module.version)},
+    label: ${quote(module.label)},
+    description: ${quote(module.description)},
+    menus: [],
+    adminRoutes: [],
+    permissions: [
+${actions
+  .map(
+    (action) =>
+      `      { key: ${quote(fieldPermission(definition, action))}, label: ${quote(`${entity.label}${actionLabel(action)}`)}, module: ${quote(module.name)}, moduleLabel: ${quote(module.label)}, resource: ${quote(entity.resource)}, resourceLabel: ${quote(entity.label)}, action: ${quote(action)} },`,
+  )
+  .join("\n")}
+    ],
+    apiPermissions: [
+${(["read", "readOne", "create", "update", "delete"] as const)
+  .map((action) => {
+    const method =
+      action === "read" || action === "readOne"
+        ? "GET"
+        : action === "create"
+          ? "POST"
+          : action === "update"
+            ? "PUT"
+            : "DELETE";
+    const path =
+      action === "read" || action === "create"
+        ? entity.route
+        : `${entity.route}/:id`;
+    const permissionAction = action === "readOne" ? "read" : action;
+    return `      { method: ${quote(method)}, path: ${quote(path)}, permissionKey: ${quote(fieldPermission(definition, permissionAction))}, featureKey: ${quote(entity.featureKey)} },`;
+  })
+  .join("\n")}
+    ],
+    features: [{
+      key: featureKey(${quote(entity.featureKey)}), label: ${quote(entity.featureLabel)}, module: ${quote(module.name)},
+      visible: "visible", enabled: true, stage: "stable", ${licenseVersions}
+    }],
+    migrations: [],
+    schemaExports: [],
+    tasks: [],
+    tools: [],
+    providers: [],
+    auditActions: ["crud.create", "crud.update", "crud.delete", "security.denied"],
+    metadata: { canonicalTable: ${quote(entity.table)}, generatedCrud: true },
+  };
+}
+`;
+}
+
+function actionLabel(action: "read" | "create" | "update" | "delete") {
+  return { read: "查看", create: "新增", update: "修改", delete: "删除" }[
+    action
+  ];
+}

package/template/packages/crud-generator/src/templates/project.ts

@@ -0,0 +1,161 @@
+import type { CrudModuleDefinition } from "../definition.js";
+import { camel, quote } from "../template-helpers.js";
+
+export function packageTemplate(definition: CrudModuleDefinition): string {
+  return `${JSON.stringify(
+    {
+      name: `@windy-module/${definition.module.name}`,
+      version: definition.module.version,
+      private: true,
+      type: "module",
+      scripts: {
+        typecheck: "tsc --noEmit --project tsconfig.json",
+        test: "bun test src",
+      },
+      dependencies: {
+        "@windy/modules": "workspace:*",
+        "@windy/shared": "workspace:*",
+        "drizzle-orm": "^0.45.2",
+        zod: "^4.4.3",
+      },
+    },
+    null,
+    2,
+  )}\n`;
+}
+
+export function tsconfigTemplate(): string {
+  return `${JSON.stringify(
+    {
+      compilerOptions: {
+        target: "esnext",
+        module: "esnext",
+        lib: ["esnext", "dom"],
+        moduleResolution: "bundler",
+        strict: true,
+        noImplicitAny: true,
+        esModuleInterop: true,
+        skipLibCheck: true,
+        types: ["bun"],
+      },
+      include: ["src/**/*"],
+    },
+    null,
+    2,
+  )}\n`;
+}
+
+export function barrelTemplate(): string {
+  const files = [
+    "domain",
+    "dto",
+    "schema",
+    "repository",
+    "drizzle-repository",
+    "service",
+    "routes",
+    "manifest",
+  ];
+  return `${files.map((file) => `export * from "./${file}.js";`).join("\n")}\n`;
+}
+
+export function serviceTestTemplate(definition: CrudModuleDefinition): string {
+  const { entity } = definition;
+  const variable = camel(entity.name);
+  const validFields = entity.fields
+    .filter((field) => field.required)
+    .map((field) => `    ${field.name}: ${fixtureValue(field.type)},`)
+    .join("\n");
+  return `import { describe, expect, test } from "bun:test";
+import type { ${entity.name} } from "./domain.js";
+import type { ${entity.name}Repository } from "./repository.js";
+import { ${entity.name}Service } from "./service.js";
+
+describe("${entity.label}生成切片", () => {
+  test("DTO 校验后通过 Repository 端口创建", async () => {
+    let received: unknown;
+    const repository = {
+      async create(input, actorId) {
+        received = { input, actorId };
+        return { id: "id_1", status: "active", ...input, createdAt: "2026-01-01T00:00:00.000Z", createdBy: actorId, updatedAt: "2026-01-01T00:00:00.000Z", updatedBy: actorId } as ${entity.name};
+      },
+    } as ${entity.name}Repository;
+    const service = new ${entity.name}Service(repository);
+    const ${variable} = await service.create({
+${validFields}
+    }, "user_1");
+    expect(${variable}.id).toBe("id_1");
+    expect(received).toMatchObject({ actorId: "user_1" });
+  });
+
+  test("拒绝未知字段", async () => {
+    const service = new ${entity.name}Service({} as ${entity.name}Repository);
+    expect(() => service.create({ unknown: true }, "user_1")).toThrow();
+  });
+});
+`;
+}
+
+export function routeTestTemplate(definition: CrudModuleDefinition): string {
+  const { entity } = definition;
+  const relativeRoute = entity.route.replace(/^\/api/, "");
+  const validFields = entity.fields
+    .filter((field) => field.required)
+    .map((field) => `      ${field.name}: ${fixtureValue(field.type)},`)
+    .join("\n");
+  return `import { describe, expect, test } from "bun:test";
+import type { ${entity.name} } from "./domain.js";
+import type { ${entity.name}Repository } from "./repository.js";
+import { register${entity.name}Routes } from "./routes.js";
+import type { CrudAccessPolicy, CrudRouteApp } from "./routes.js";
+import { ${entity.name}Service } from "./service.js";
+
+describe("${entity.label}生成路由", () => {
+  test("写入先通过完整 Guard policy 再审计", async () => {
+    const handlers = new Map<string, (context: unknown) => unknown>();
+    const app = routeApp(handlers);
+    let policy: CrudAccessPolicy | undefined;
+    const events: Array<{ action: string; policy?: string }> = [];
+    const repository = {
+      async create(input, actorId) {
+        return { id: "id_1", status: "active", ...input, createdAt: "2026-01-01T00:00:00.000Z", createdBy: actorId, updatedAt: "2026-01-01T00:00:00.000Z", updatedBy: actorId } as ${entity.name};
+      },
+    } as ${entity.name}Repository;
+    register${entity.name}Routes(
+      app,
+      new ${entity.name}Service(repository),
+      { async authorize(_context, input) { policy = input; return { allowed: true, reason: "allowed" }; } },
+      { write(event, policy) { events.push({ action: event.action, policy }); } },
+    );
+    const result = await handlers.get(${quote(`POST ${relativeRoute}`)})?.({
+      guardContext: { actor: { id: "user_1", name: "测试员", type: "user" }, requestId: "req_1" },
+      body: {
+${validFields}
+      },
+    });
+    expect((result as ${entity.name}).id).toBe("id_1");
+    expect(policy?.guardOrder).toEqual(["license", "license-version", "feature", "permission"]);
+    expect(policy?.permission.permissionKey).toBe(${quote(`${definition.module.name}.${entity.resource}.create`)});
+    expect(events).toHaveLength(1);
+    expect(events[0]).toMatchObject({ action: "crud.create", policy: "critical" });
+  });
+});
+
+function routeApp(handlers: Map<string, (context: unknown) => unknown>): CrudRouteApp {
+  return {
+    get(path, handler) { handlers.set(\`GET \${path}\`, handler); },
+    post(path, handler) { handlers.set(\`POST \${path}\`, handler); },
+    put(path, handler) { handlers.set(\`PUT \${path}\`, handler); },
+    delete(path, handler) { handlers.set(\`DELETE \${path}\`, handler); },
+  };
+}
+`;
+}
+
+function fixtureValue(type: string): string {
+  if (type === "integer") return "1";
+  if (type === "boolean") return "true";
+  if (type === "datetime") return quote("2026-01-01T00:00:00.000Z");
+  if (type === "json") return "{}";
+  return quote("示例值");
+}

package/template/packages/crud-generator/src/templates/repository.ts

@@ -0,0 +1,23 @@
+import type { CrudModuleDefinition } from "../definition.js";
+
+export function repositoryTemplate(definition: CrudModuleDefinition): string {
+  const { entity } = definition;
+  return `import type { PageResult } from "@windy/shared";
+import type { ${entity.name}, ${entity.name}CreateInput, ${entity.name}UpdateInput } from "./domain.js";
+
+export interface ${entity.name}ListQuery {
+  page: number;
+  pageSize: number;
+  q?: string;
+  includeDeleted?: boolean;
+}
+
+export interface ${entity.name}Repository {
+  list(query: ${entity.name}ListQuery): Promise<PageResult<${entity.name}>>;
+  get(id: string): Promise<${entity.name} | undefined>;
+  create(input: ${entity.name}CreateInput, actorId: string): Promise<${entity.name}>;
+  update(id: string, input: ${entity.name}UpdateInput, actorId: string): Promise<${entity.name} | undefined>;
+  softDelete(id: string, actorId: string): Promise<${entity.name} | undefined>;
+}
+`;
+}

package/template/packages/crud-generator/src/templates/routes.ts

@@ -0,0 +1,158 @@
+import type { CrudModuleDefinition } from "../definition.js";
+import { fieldPermission, quote } from "../template-helpers.js";
+
+export function routesTemplate(definition: CrudModuleDefinition): string {
+  const { entity } = definition;
+  const relativeRoute = entity.route.replace(/^\/api/, "");
+  const licenseVersions = entity.allowedLicenseVersions?.length
+    ? `allowedLicenseVersions: [${entity.allowedLicenseVersions.map((key) => `licenseVersionKey(${quote(key)})`).join(", ")}],`
+    : "";
+  const guardOrder = entity.allowedLicenseVersions?.length
+    ? '["license", "license-version", "feature", "permission"]'
+    : '["license", "feature", "permission"]';
+  const policies = (["read", "readOne", "create", "update", "delete"] as const)
+    .map(
+      (action) => `  ${action}: {
+    guardOrder,
+    permission: {
+      method: ${quote(action === "read" || action === "readOne" ? "GET" : action === "create" ? "POST" : action === "update" ? "PUT" : "DELETE")},
+      path: ${quote(action === "read" || action === "create" ? entity.route : `${entity.route}/:id`)},
+      permissionKey: ${quote(fieldPermission(definition, action === "readOne" ? "read" : action))},
+    },
+    feature,
+  },`,
+    )
+    .join("\n");
+  return `import { randomUUIDv7 } from "bun";
+import { featureKey, licenseVersionKey } from "@windy/shared";
+import type { ApiPermissionBinding, AuditEvent, FeatureFlagDefinition } from "@windy/shared";
+import { ZodError } from "zod";
+import type { ${entity.name}Service } from "./service.js";
+
+export interface CrudRouteApp {
+  get(path: string, handler: (context: unknown) => unknown): unknown;
+  post(path: string, handler: (context: unknown) => unknown): unknown;
+  put(path: string, handler: (context: unknown) => unknown): unknown;
+  delete(path: string, handler: (context: unknown) => unknown): unknown;
+}
+
+export interface CrudRouteContext {
+  guardContext: {
+    actor: { id: string; name: string; type: "user" | "service" | "anonymous" };
+    requestId: string;
+  };
+  body?: unknown;
+  params?: Record<string, string | undefined>;
+  query?: Record<string, string | undefined>;
+}
+
+export interface CrudAccessPolicy {
+  guardOrder: readonly ("license" | "license-version" | "feature" | "permission")[];
+  permission: ApiPermissionBinding;
+  feature: FeatureFlagDefinition;
+}
+
+export interface CrudAccessPort {
+  authorize(context: CrudRouteContext, policy: CrudAccessPolicy): Promise<{ allowed: boolean; reason: string }>;
+}
+
+export interface CrudAuditPort {
+  write(event: AuditEvent, policy?: "ordinary" | "critical"): Promise<void> | void;
+}
+
+const guardOrder = ${guardOrder} as const;
+const feature: FeatureFlagDefinition = {
+  key: featureKey(${quote(entity.featureKey)}),
+  label: ${quote(entity.featureLabel)},
+  module: ${quote(definition.module.name)},
+  enabled: true,
+  visible: "visible",
+  stage: "stable",
+  ${licenseVersions}
+};
+
+export const ${entity.name}RoutePolicies = {
+${policies}
+} satisfies Record<string, CrudAccessPolicy>;
+
+export function register${entity.name}Routes(
+  app: CrudRouteApp,
+  service: ${entity.name}Service,
+  access: CrudAccessPort,
+  audit: CrudAuditPort,
+) {
+  app.get(${quote(relativeRoute)}, (raw) => guarded(raw, "read", access, async (context) => {
+    const query = context.query || {};
+    return service.list({
+      page: positiveInt(query.page, 1),
+      pageSize: Math.min(100, positiveInt(query.pageSize, 20)),
+      q: query.q,
+      includeDeleted: query.includeDeleted === "true",
+    });
+  }));
+  app.get(${quote(`${relativeRoute}/:id`)}, (raw) => guarded(raw, "readOne", access, async (context) => {
+    const id = requiredId(context);
+    return (await service.get(id)) || notFound(id);
+  }));
+  app.post(${quote(relativeRoute)}, (raw) => guarded(raw, "create", access, async (context) => {
+    const item = await service.create(context.body, context.guardContext.actor.id);
+    await audit.write(event(context, "crud.create", item.id), "critical");
+    return item;
+  }));
+  app.put(${quote(`${relativeRoute}/:id`)}, (raw) => guarded(raw, "update", access, async (context) => {
+    const id = requiredId(context);
+    const item = await service.update(id, context.body, context.guardContext.actor.id);
+    if (!item) return notFound(id);
+    await audit.write(event(context, "crud.update", id), "critical");
+    return item;
+  }));
+  app.delete(${quote(`${relativeRoute}/:id`)}, (raw) => guarded(raw, "delete", access, async (context) => {
+    const id = requiredId(context);
+    const item = await service.delete(id, context.guardContext.actor.id);
+    if (!item) return notFound(id);
+    await audit.write(event(context, "crud.delete", id), "critical");
+    return item;
+  }));
+  return app;
+}
+
+async function guarded(
+  raw: unknown,
+  action: keyof typeof ${entity.name}RoutePolicies,
+  access: CrudAccessPort,
+  execute: (context: CrudRouteContext) => Promise<unknown>,
+) {
+  const context = raw as CrudRouteContext;
+  const decision = await access.authorize(context, ${entity.name}RoutePolicies[action]);
+  if (!decision.allowed) return Response.json({ error: "FORBIDDEN", reason: decision.reason }, { status: 403 });
+  try {
+    return await execute(context);
+  } catch (error) {
+    if (error instanceof ZodError) return Response.json({ error: "INVALID_INPUT", issues: error.issues }, { status: 400 });
+    throw error;
+  }
+}
+
+function requiredId(context: CrudRouteContext): string {
+  const id = context.params?.id;
+  if (!id) throw new Error("缺少资源 ID");
+  return id;
+}
+function positiveInt(value: string | undefined, fallback: number): number {
+  const parsed = value ? Number.parseInt(value, 10) : fallback;
+  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : fallback;
+}
+function notFound(id: string) {
+  return Response.json({ error: "NOT_FOUND", resource: ${quote(entity.resource)}, id }, { status: 404 });
+}
+function event(context: CrudRouteContext, action: AuditEvent["action"], id: string): AuditEvent {
+  const { actor, requestId } = context.guardContext;
+  return {
+    id: randomUUIDv7(), action, outcome: "success",
+    actor: { id: actor.id, name: actor.name, type: actor.type === "anonymous" ? "user" : actor.type },
+    target: { type: ${quote(entity.resource)}, id }, module: ${quote(definition.module.name)},
+    requestId, occurredAt: new Date().toISOString(),
+  };
+}
+`;
+}

package/template/packages/crud-generator/src/templates/schema.ts

@@ -0,0 +1,45 @@
+import type { CrudModuleDefinition } from "../definition.js";
+import {
+  camel,
+  columnType,
+  importsForColumns,
+  quote,
+} from "../template-helpers.js";
+
+export function schemaTemplate(definition: CrudModuleDefinition): string {
+  const { entity } = definition;
+  const tableName = camel(entity.pluralName);
+  const indexes = entity.fields
+    .filter((field) => field.unique)
+    .map(
+      (field) =>
+        `    uniqueIndex(${quote(`uk_${entity.table}_${field.column}`)}).on(table.${field.name}),`,
+    );
+  return `import {
+${importsForColumns(definition)
+  .map((name) => `  ${name},`)
+  .join("\n")}
+} from "drizzle-orm/pg-core";
+
+export const ${tableName} = pgTable(
+  ${quote(entity.table)},
+  {
+    id: varchar("id", { length: 64 }).primaryKey(),
+${entity.fields
+  .map(
+    (field) =>
+      `    ${field.name}: ${columnType(field)}${field.required ? ".notNull()" : ""},`,
+  )
+  .join("\n")}
+    status: varchar("status", { length: 32 }).notNull().default("active"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    createdBy: varchar("created_by", { length: 64 }).notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedBy: varchar("updated_by", { length: 64 }).notNull(),
+    deletedAt: timestamp("deleted_at", { withTimezone: true }),
+    deletedBy: varchar("deleted_by", { length: 64 }),
+  },
+${indexes.length ? `  (table) => [\n${indexes.join("\n")}\n  ],` : "  () => [],"}
+);
+`;
+}

package/template/packages/crud-generator/src/templates/service.ts

@@ -0,0 +1,32 @@
+import type { CrudModuleDefinition } from "../definition.js";
+
+export function serviceTemplate(definition: CrudModuleDefinition): string {
+  const { entity } = definition;
+  return `import { create${entity.name}Schema, update${entity.name}Schema } from "./dto.js";
+import type { ${entity.name}Repository, ${entity.name}ListQuery } from "./repository.js";
+
+export class ${entity.name}Service {
+  constructor(private readonly repository: ${entity.name}Repository) {}
+
+  list(query: ${entity.name}ListQuery) {
+    return this.repository.list(query);
+  }
+
+  get(id: string) {
+    return this.repository.get(id);
+  }
+
+  create(input: unknown, actorId: string) {
+    return this.repository.create(create${entity.name}Schema.parse(input), actorId);
+  }
+
+  update(id: string, input: unknown, actorId: string) {
+    return this.repository.update(id, update${entity.name}Schema.parse(input), actorId);
+  }
+
+  delete(id: string, actorId: string) {
+    return this.repository.softDelete(id, actorId);
+  }
+}
+`;
+}