create-nextdevtpl 2.6.0

package/template/src/adapters/registry.ts

@@ -0,0 +1,228 @@
+import {
+  defineServiceAdapter,
+  type ServiceAdapterManifest,
+  type ServiceKind,
+  validateServiceAdapterManifests,
+} from "@/core/services";
+
+const manifests = [
+  defineServiceAdapter({
+    id: "payment:creem",
+    service: "payment",
+    source: "src/adapters/payment/creem.ts",
+    runtime: "node",
+    packages: [],
+    env: ["CREEM_API_KEY", "CREEM_WEBHOOK_SECRET"],
+    bindings: [],
+  }),
+  defineServiceAdapter({
+    id: "payment:stripe",
+    service: "payment",
+    source: "src/adapters/payment/stripe.ts",
+    runtime: "universal",
+    packages: [],
+    env: ["STRIPE_SECRET_KEY", "STRIPE_WEBHOOK_SECRET"],
+    bindings: [],
+  }),
+  defineServiceAdapter({
+    id: "storage:s3-compatible",
+    service: "storage",
+    source: "src/adapters/storage/s3-compatible.ts",
+    runtime: "node",
+    packages: ["@aws-sdk/client-s3", "@aws-sdk/s3-request-presigner"],
+    env: [
+      "STORAGE_ACCESS_KEY_ID",
+      "STORAGE_SECRET_ACCESS_KEY",
+      "STORAGE_ENDPOINT",
+      "STORAGE_REGION",
+    ],
+    bindings: [],
+  }),
+  defineServiceAdapter({
+    id: "storage:r2-binding",
+    service: "storage",
+    source: "src/adapters/storage/r2-binding.ts",
+    runtime: "worker",
+    packages: [],
+    env: [],
+    bindings: ["R2Bucket"],
+  }),
+  defineServiceAdapter({
+    id: "mail:disabled",
+    service: "mail",
+    source: "src/adapters/mail/disabled.ts",
+    runtime: "universal",
+    packages: [],
+    env: [],
+    bindings: [],
+  }),
+  defineServiceAdapter({
+    id: "mail:resend",
+    service: "mail",
+    source: "src/adapters/mail/resend.ts",
+    runtime: "universal",
+    packages: ["resend"],
+    env: ["RESEND_API_KEY", "EMAIL_FROM"],
+    bindings: [],
+  }),
+  defineServiceAdapter({
+    id: "mail:smtp",
+    service: "mail",
+    source: "src/adapters/mail/smtp.ts",
+    runtime: "node",
+    packages: ["nodemailer"],
+    env: ["SMTP_HOST", "SMTP_PORT", "SMTP_SECURE", "SMTP_USER", "SMTP_PASS"],
+    bindings: [],
+  }),
+  defineServiceAdapter({
+    id: "mail:cloudflare-email",
+    service: "mail",
+    source: "src/adapters/mail/cloudflare-email.ts",
+    runtime: "worker",
+    packages: [],
+    env: ["EMAIL_FROM"],
+    bindings: ["SendEmail"],
+  }),
+  defineServiceAdapter({
+    id: "ai:openai-compatible",
+    service: "ai",
+    source: "src/adapters/ai/openai-compatible.ts",
+    runtime: "universal",
+    packages: ["openai"],
+    env: [
+      "AI_PROVIDER",
+      "OPENAI_API_KEY",
+      "OPENAI_MODEL",
+      "DEEPSEEK_API_KEY",
+      "DEEPSEEK_MODEL",
+      "MIMO_API_KEY",
+      "MIMO_MODEL",
+      "CF_AIG_BASE_URL",
+      "CF_AIG_TOKEN",
+    ],
+    bindings: [],
+  }),
+  defineServiceAdapter({
+    id: "ai:anthropic",
+    service: "ai",
+    source: "src/adapters/ai/anthropic.ts",
+    runtime: "universal",
+    packages: [],
+    env: ["ANTHROPIC_API_KEY", "ANTHROPIC_MODEL"],
+    bindings: [],
+  }),
+  defineServiceAdapter({
+    id: "ai:workers-ai",
+    service: "ai",
+    source: "src/adapters/ai/workers-ai.ts",
+    runtime: "worker",
+    packages: [],
+    env: ["WORKERS_AI_MODEL"],
+    bindings: ["Ai"],
+  }),
+  defineServiceAdapter({
+    id: "jobs:inngest",
+    service: "jobs",
+    source: "src/adapters/jobs/inngest",
+    runtime: "universal",
+    packages: ["inngest"],
+    env: ["INNGEST_EVENT_KEY", "INNGEST_SIGNING_KEY"],
+    bindings: [],
+  }),
+  defineServiceAdapter({
+    id: "jobs:cloudflare-workflows",
+    service: "jobs",
+    source: "src/adapters/jobs/cloudflare-workflows.ts",
+    runtime: "worker",
+    packages: [],
+    env: [],
+    bindings: ["Workflow"],
+  }),
+  defineServiceAdapter({
+    id: "rate-limit:noop",
+    service: "rate-limit",
+    source: "src/adapters/rate-limit/noop.ts",
+    runtime: "universal",
+    packages: [],
+    env: [],
+    bindings: [],
+  }),
+  defineServiceAdapter({
+    id: "rate-limit:upstash",
+    service: "rate-limit",
+    source: "src/adapters/rate-limit/upstash.ts",
+    runtime: "universal",
+    packages: ["@upstash/ratelimit", "@upstash/redis"],
+    env: ["UPSTASH_REDIS_REST_URL", "UPSTASH_REDIS_REST_TOKEN"],
+    bindings: [],
+  }),
+  defineServiceAdapter({
+    id: "rate-limit:cloudflare-rate-limit",
+    service: "rate-limit",
+    source: "src/adapters/rate-limit/cloudflare.ts",
+    runtime: "worker",
+    packages: [],
+    env: [],
+    bindings: ["RateLimit"],
+  }),
+] as const satisfies readonly ServiceAdapterManifest[];
+
+const errors = validateServiceAdapterManifests(manifests);
+if (errors.length > 0) {
+  throw new Error(`服务适配器注册失败：\n${errors.join("\n")}`);
+}
+
+export const serviceAdapterRegistry = manifests;
+export type ServiceAdapterId = (typeof manifests)[number]["id"];
+type RegisteredServiceAdapter = (typeof manifests)[number];
+type ServiceAdapterIdFor<Kind extends ServiceKind> = Extract<
+  RegisteredServiceAdapter,
+  { service: Kind }
+>["id"];
+
+export const defaultServiceAdapters = {
+  payment: "payment:creem",
+  storage: "storage:s3-compatible",
+  mail: "mail:resend",
+  ai: "ai:openai-compatible",
+  jobs: "jobs:inngest",
+  "rate-limit": "rate-limit:upstash",
+} as const satisfies Record<ServiceKind, ServiceAdapterId>;
+
+export type ServiceAdapterChoices = {
+  readonly [Kind in ServiceKind]: ServiceAdapterIdFor<Kind>;
+};
+
+export interface ServiceAdapterSelection {
+  bindings: readonly string[];
+  env: readonly string[];
+  manifests: readonly ServiceAdapterManifest[];
+  packages: readonly string[];
+  sources: readonly string[];
+}
+
+export function createServiceAdapterSelection(
+  choices: ServiceAdapterChoices
+): ServiceAdapterSelection {
+  const selectedIds = new Set<ServiceAdapterId>(Object.values(choices));
+  const selected = serviceAdapterRegistry.filter((manifest) =>
+    selectedIds.has(manifest.id)
+  );
+
+  if (selected.length !== Object.keys(choices).length) {
+    throw new Error("服务适配器选择包含未注册项或重复项");
+  }
+  for (const manifest of selected) {
+    if (choices[manifest.service] !== manifest.id) {
+      throw new Error(`适配器 ${manifest.id} 的能力分类不匹配`);
+    }
+  }
+
+  return {
+    manifests: selected,
+    sources: selected.map((manifest) => manifest.source),
+    packages: [...new Set(selected.flatMap((manifest) => manifest.packages))],
+    env: [...new Set(selected.flatMap((manifest) => manifest.env))],
+    bindings: [...new Set(selected.flatMap((manifest) => manifest.bindings))],
+  };
+}

package/template/src/adapters/storage/index.ts

@@ -0,0 +1,3 @@
+export { createR2BindingStorageAdapter } from "./r2-binding";
+export type { R2BucketPort } from "./r2-binding";
+export { createS3CompatibleStorageAdapter } from "./s3-compatible";

package/template/src/adapters/storage/r2-binding.ts

@@ -0,0 +1,105 @@
+import {
+  AdapterError,
+  executeAdapterOperation,
+  type StorageAdapter,
+  type StorageWriteInput,
+} from "@/core/services";
+
+interface R2ObjectBodyPort {
+  arrayBuffer(): Promise<ArrayBuffer>;
+  etag?: string;
+  httpMetadata?: { contentType?: string };
+}
+
+export interface R2BucketPort {
+  delete(key: string): Promise<void>;
+  get(key: string): Promise<R2ObjectBodyPort | null>;
+  put(
+    key: string,
+    body: StorageWriteInput["body"],
+    options?: { httpMetadata?: { contentType?: string } }
+  ): Promise<unknown>;
+}
+
+export function createR2BindingStorageAdapter(
+  buckets: Readonly<Record<string, R2BucketPort>>
+): StorageAdapter {
+  const provider = "r2-binding" as const;
+
+  function getBucket(name: string): R2BucketPort {
+    const bucket = buckets[name];
+    if (!bucket) {
+      throw new AdapterError({
+        code: "configuration",
+        message: `R2 binding is not configured for bucket ${name}`,
+        provider,
+      });
+    }
+    return bucket;
+  }
+
+  function unsupported(operation: string): never {
+    throw new AdapterError({
+      code: "unsupported",
+      message: `${operation} is unavailable through an R2 binding`,
+      provider,
+    });
+  }
+
+  return {
+    provider,
+    capabilities: {
+      directRead: true,
+      directWrite: true,
+      signedDownloadUrls: false,
+      signedUploadUrls: false,
+    },
+
+    async createDownloadUrl() {
+      return unsupported("Signed download URLs");
+    },
+
+    async createUploadUrl() {
+      return unsupported("Signed upload URLs");
+    },
+
+    async deleteObject(bucket, key) {
+      await executeAdapterOperation({
+        provider,
+        fallbackMessage: "R2 object deletion failed",
+        operation: () => getBucket(bucket).delete(key),
+      });
+    },
+
+    async readObject(bucket, key) {
+      const object = await executeAdapterOperation({
+        provider,
+        fallbackMessage: "R2 object read failed",
+        operation: () => getBucket(bucket).get(key),
+      });
+      if (!object) {
+        return null;
+      }
+      return {
+        body: new Uint8Array(await object.arrayBuffer()),
+        ...(object.httpMetadata?.contentType
+          ? { contentType: object.httpMetadata.contentType }
+          : {}),
+        ...(object.etag ? { etag: object.etag } : {}),
+      };
+    },
+
+    async writeObject(input) {
+      await executeAdapterOperation({
+        provider,
+        fallbackMessage: "R2 object write failed",
+        operation: () =>
+          getBucket(input.bucket).put(input.key, input.body, {
+            ...(input.contentType
+              ? { httpMetadata: { contentType: input.contentType } }
+              : {}),
+          }),
+      });
+    },
+  };
+}

package/template/src/adapters/storage/s3-compatible.ts

@@ -0,0 +1,149 @@
+import {
+  DeleteObjectCommand,
+  GetObjectCommand,
+  PutObjectCommand,
+  S3Client,
+} from "@aws-sdk/client-s3";
+import type { PutObjectCommandInput } from "@aws-sdk/client-s3";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+
+import {
+  AdapterError,
+  executeAdapterOperation,
+  type StorageAdapter,
+  type StorageWriteInput,
+} from "@/core/services";
+
+interface S3CompatibleConfig {
+  accessKeyId?: string;
+  endpoint?: string;
+  region?: string;
+  secretAccessKey?: string;
+}
+
+function toSdkBody(
+  body: StorageWriteInput["body"]
+): NonNullable<PutObjectCommandInput["Body"]> {
+  return body instanceof ArrayBuffer ? new Uint8Array(body) : body;
+}
+
+export function createS3CompatibleStorageAdapter(
+  config: S3CompatibleConfig = {}
+): StorageAdapter {
+  const provider = "s3-compatible" as const;
+  let client: S3Client | undefined;
+
+  function getClient(): S3Client {
+    if (client) {
+      return client;
+    }
+
+    const accessKeyId = config.accessKeyId ?? process.env.STORAGE_ACCESS_KEY_ID;
+    const secretAccessKey =
+      config.secretAccessKey ?? process.env.STORAGE_SECRET_ACCESS_KEY;
+    const endpoint = config.endpoint ?? process.env.STORAGE_ENDPOINT;
+    const region = config.region ?? process.env.STORAGE_REGION ?? "auto";
+
+    if (!accessKeyId || !secretAccessKey || !endpoint) {
+      throw new AdapterError({
+        code: "configuration",
+        message:
+          "Storage credentials are incomplete; configure access key, secret and endpoint",
+        provider,
+      });
+    }
+
+    client = new S3Client({
+      region,
+      endpoint,
+      credentials: { accessKeyId, secretAccessKey },
+      forcePathStyle: true,
+    });
+    return client;
+  }
+
+  return {
+    provider,
+    capabilities: {
+      directRead: true,
+      directWrite: true,
+      signedDownloadUrls: true,
+      signedUploadUrls: true,
+    },
+
+    async createDownloadUrl(input) {
+      return executeAdapterOperation({
+        provider,
+        fallbackMessage: "Signed download URL creation failed",
+        operation: () =>
+          getSignedUrl(
+            getClient(),
+            new GetObjectCommand({ Bucket: input.bucket, Key: input.key }),
+            { expiresIn: input.expiresIn }
+          ),
+      });
+    },
+
+    async createUploadUrl(input) {
+      return executeAdapterOperation({
+        provider,
+        fallbackMessage: "Signed upload URL creation failed",
+        operation: () =>
+          getSignedUrl(
+            getClient(),
+            new PutObjectCommand({
+              Bucket: input.bucket,
+              Key: input.key,
+              ContentType: input.contentType,
+            }),
+            { expiresIn: input.expiresIn }
+          ),
+      });
+    },
+
+    async deleteObject(bucket, key) {
+      await executeAdapterOperation({
+        provider,
+        fallbackMessage: "Object deletion failed",
+        operation: () =>
+          getClient().send(
+            new DeleteObjectCommand({ Bucket: bucket, Key: key })
+          ),
+      });
+    },
+
+    async readObject(bucket, key) {
+      const result = await executeAdapterOperation({
+        provider,
+        fallbackMessage: "Object read failed",
+        operation: () =>
+          getClient().send(new GetObjectCommand({ Bucket: bucket, Key: key })),
+      });
+      if (!result.Body) {
+        return null;
+      }
+
+      return {
+        body: new Uint8Array(await result.Body.transformToByteArray()),
+        ...(result.ContentType ? { contentType: result.ContentType } : {}),
+        ...(result.ETag ? { etag: result.ETag } : {}),
+      };
+    },
+
+    async writeObject(input) {
+      await executeAdapterOperation({
+        provider,
+        fallbackMessage: "Object write failed",
+        operation: () =>
+          getClient().send(
+            new PutObjectCommand({
+              Bucket: input.bucket,
+              Key: input.key,
+              Body: toSdkBody(input.body),
+              ...(input.contentType ? { ContentType: input.contentType } : {}),
+            })
+          ),
+      });
+    },
+  };
+}

package/template/src/app/[locale]/(admin)/admin/layout.tsx

@@ -0,0 +1,36 @@
+import { AdminSidebar } from "@/features/admin";
+import { checkAdmin } from "@/lib/auth/admin";
+
+/**
+ * Admin 布局组件
+ *
+ * 功能:
+ * - RBAC 权限检查 (只有 admin 角色可访问)
+ * - Admin 专用侧边栏（永远深色，控制台调性）
+ * - 内容区跟随用户主题，使用设计系统 token（不再硬编码 slate/white）
+ */
+export default async function AdminLayout({
+  children,
+}: {
+  children: React.ReactNode;
+}) {
+  // 权限检查 - 非管理员会被重定向
+  await checkAdmin();
+
+  return (
+    <div className="min-h-screen bg-muted/30">
+      <AdminSidebar />
+      <div className="pl-64">
+        {/* Admin 顶栏 */}
+        <header className="sticky top-0 z-30 flex h-14 items-center gap-3 border-b bg-background/80 px-6 backdrop-blur-xl">
+          <span className="rounded bg-destructive/10 px-1.5 py-0.5 font-mono text-[10px] font-semibold tracking-[0.14em] text-destructive uppercase">
+            ADMIN
+          </span>
+          <h1 className="text-lg font-semibold tracking-tight">管理后台</h1>
+        </header>
+        {/* 主内容区域 */}
+        <main className="p-6">{children}</main>
+      </div>
+    </div>
+  );
+}