create-windy 0.1.0

package/template/apps/server/src/storage/drizzle-upload-repository.ts

@@ -0,0 +1,248 @@
+import {
+  fileMetadata,
+  fileUploadParts,
+  fileUploadSessions,
+} from "@windy/database";
+import {
+  artifactRef,
+  sha256ContentHash,
+  type FileMetadata,
+  type NewUploadSession,
+  type UploadPart,
+  type UploadRepository,
+  type UploadSession,
+} from "@windy/storage";
+import { and, asc, eq, lte, ne, sql } from "drizzle-orm";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+
+export class DrizzleUploadRepository implements UploadRepository {
+  constructor(private readonly db: NodePgDatabase) {}
+
+  async createSession(input: NewUploadSession) {
+    const [row] = await this.db
+      .insert(fileUploadSessions)
+      .values({
+        ...input,
+        expectedSha256: input.expectedContentHash?.value,
+        expiresAt: new Date(input.expiresAt),
+        fileExpiresAt: input.fileExpiresAt
+          ? new Date(input.fileExpiresAt)
+          : undefined,
+        status: "uploading",
+        createdAt: new Date(input.createdAt),
+        updatedAt: new Date(input.createdAt),
+      })
+      .returning();
+    if (!row) throw new Error("上传会话创建失败");
+    return mapSession(row);
+  }
+
+  async getSession(id: string) {
+    const [row] = await this.db
+      .select()
+      .from(fileUploadSessions)
+      .where(eq(fileUploadSessions.id, id))
+      .limit(1);
+    return row ? mapSession(row) : undefined;
+  }
+
+  async getPart(sessionId: string, partNumber: number) {
+    const [row] = await this.db
+      .select()
+      .from(fileUploadParts)
+      .where(
+        and(
+          eq(fileUploadParts.sessionId, sessionId),
+          eq(fileUploadParts.partNumber, partNumber),
+        ),
+      )
+      .limit(1);
+    return row ? mapPart(row) : undefined;
+  }
+
+  async listParts(sessionId: string) {
+    const rows = await this.db
+      .select()
+      .from(fileUploadParts)
+      .where(eq(fileUploadParts.sessionId, sessionId))
+      .orderBy(asc(fileUploadParts.partNumber));
+    return rows.map(mapPart);
+  }
+
+  async commitPart(part: UploadPart, expectedReceivedByteSize: number) {
+    return this.db.transaction(async (tx) => {
+      const [updated] = await tx
+        .update(fileUploadSessions)
+        .set({
+          receivedByteSize: sql`${fileUploadSessions.receivedByteSize} + ${part.byteSize}`,
+          nextPartNumber: sql`${fileUploadSessions.nextPartNumber} + 1`,
+          updatedAt: new Date(part.createdAt),
+        })
+        .where(
+          and(
+            eq(fileUploadSessions.id, part.sessionId),
+            eq(fileUploadSessions.status, "uploading"),
+            eq(fileUploadSessions.receivedByteSize, expectedReceivedByteSize),
+            eq(fileUploadSessions.nextPartNumber, part.partNumber),
+          ),
+        )
+        .returning({ id: fileUploadSessions.id });
+      if (!updated) return false;
+      await tx.insert(fileUploadParts).values({
+        ...part,
+        sha256: part.contentHash.value,
+        createdAt: new Date(part.createdAt),
+      });
+      return true;
+    });
+  }
+
+  async completeSession(
+    sessionId: string,
+    expectedReceivedByteSize: number,
+    file: FileMetadata,
+    updatedAt: string,
+  ) {
+    return this.db.transaction(async (tx) => {
+      const [updated] = await tx
+        .update(fileUploadSessions)
+        .set({
+          status: "completed",
+          fileId: file.id,
+          updatedAt: new Date(updatedAt),
+        })
+        .where(
+          and(
+            eq(fileUploadSessions.id, sessionId),
+            eq(fileUploadSessions.status, "uploading"),
+            eq(fileUploadSessions.receivedByteSize, expectedReceivedByteSize),
+            eq(fileUploadSessions.expectedByteSize, expectedReceivedByteSize),
+          ),
+        )
+        .returning({ id: fileUploadSessions.id });
+      if (!updated) return false;
+      await tx.insert(fileMetadata).values({
+        ...file,
+        sha256: file.contentHash.value,
+        expiresAt: file.expiresAt ? new Date(file.expiresAt) : undefined,
+        createdAt: new Date(file.createdAt),
+      });
+      return true;
+    });
+  }
+
+  async abortSession(id: string, ownerId: string, updatedAt: string) {
+    const rows = await this.db
+      .update(fileUploadSessions)
+      .set({ status: "aborted", updatedAt: new Date(updatedAt) })
+      .where(
+        and(
+          eq(fileUploadSessions.id, id),
+          eq(fileUploadSessions.ownerId, ownerId),
+          eq(fileUploadSessions.status, "uploading"),
+        ),
+      )
+      .returning({ id: fileUploadSessions.id });
+    return rows.length === 1;
+  }
+
+  async getFile(id: string) {
+    const [row] = await this.db
+      .select()
+      .from(fileMetadata)
+      .where(eq(fileMetadata.id, id))
+      .limit(1);
+    return row ? mapFile(row) : undefined;
+  }
+
+  async listExpiredSessions(now: string, limit: number) {
+    const rows = await this.db
+      .select()
+      .from(fileUploadSessions)
+      .where(
+        and(
+          ne(fileUploadSessions.status, "completed"),
+          lte(fileUploadSessions.expiresAt, new Date(now)),
+        ),
+      )
+      .orderBy(asc(fileUploadSessions.expiresAt))
+      .limit(limit);
+    return rows.map(mapSession);
+  }
+
+  async listExpiredFiles(now: string, limit: number) {
+    const rows = await this.db
+      .select()
+      .from(fileMetadata)
+      .where(lte(fileMetadata.expiresAt, new Date(now)))
+      .orderBy(asc(fileMetadata.expiresAt))
+      .limit(limit);
+    return rows.map(mapFile);
+  }
+
+  async listArtifactRefs() {
+    const [partRows, fileRows] = await Promise.all([
+      this.db
+        .select({ artifactRef: fileUploadParts.artifactRef })
+        .from(fileUploadParts),
+      this.db
+        .select({ artifactRef: fileMetadata.artifactRef })
+        .from(fileMetadata),
+    ]);
+    return [...partRows, ...fileRows].map((row) =>
+      artifactRef(row.artifactRef),
+    );
+  }
+
+  async deleteParts(sessionId: string) {
+    await this.db
+      .delete(fileUploadParts)
+      .where(eq(fileUploadParts.sessionId, sessionId));
+  }
+
+  async deleteSession(id: string) {
+    await this.db
+      .delete(fileUploadSessions)
+      .where(eq(fileUploadSessions.id, id));
+  }
+
+  async deleteFile(id: string) {
+    await this.db.delete(fileMetadata).where(eq(fileMetadata.id, id));
+  }
+}
+
+function mapSession(
+  row: typeof fileUploadSessions.$inferSelect,
+): UploadSession {
+  return {
+    ...row,
+    status: row.status as UploadSession["status"],
+    expectedContentHash: row.expectedSha256
+      ? sha256ContentHash(row.expectedSha256)
+      : undefined,
+    expiresAt: row.expiresAt.toISOString(),
+    fileExpiresAt: row.fileExpiresAt?.toISOString(),
+    fileId: row.fileId ?? undefined,
+    createdAt: row.createdAt.toISOString(),
+    updatedAt: row.updatedAt.toISOString(),
+  };
+}
+
+function mapPart(row: typeof fileUploadParts.$inferSelect): UploadPart {
+  return {
+    ...row,
+    artifactRef: artifactRef(row.artifactRef),
+    contentHash: sha256ContentHash(row.sha256),
+    createdAt: row.createdAt.toISOString(),
+  };
+}
+
+function mapFile(row: typeof fileMetadata.$inferSelect): FileMetadata {
+  return {
+    ...row,
+    artifactRef: artifactRef(row.artifactRef),
+    contentHash: sha256ContentHash(row.sha256),
+    expiresAt: row.expiresAt?.toISOString(),
+    createdAt: row.createdAt.toISOString(),
+  };
+}

package/template/apps/server/src/storage/route-support.ts

@@ -0,0 +1,84 @@
+import { UploadError, type OpenedFile } from "@windy/storage";
+
+export function downloadResponse(file: OpenedFile) {
+  return new Response(file.body, {
+    headers: fileHeaders(file, "attachment"),
+  });
+}
+
+export function publicImageResponse(file: OpenedFile) {
+  return new Response(file.body, {
+    headers: {
+      ...fileHeaders(file, "inline"),
+      "cache-control": "public, max-age=300",
+      "x-content-type-options": "nosniff",
+    },
+  });
+}
+
+function fileHeaders(file: OpenedFile, disposition: "attachment" | "inline") {
+  return {
+    "content-type": file.mimeType,
+    "content-length": String(file.byteSize),
+    "content-disposition": `${disposition}; filename="file.${file.extension}"; filename*=UTF-8''${encodeURIComponent(file.filename)}`,
+    "x-content-sha256": file.contentHash.value,
+    etag: `"sha256-${file.contentHash.value}"`,
+  };
+}
+
+export function uploadError(error: unknown) {
+  if (!(error instanceof UploadError)) throw error;
+  const status =
+    error.code === "UPLOAD_FORBIDDEN"
+      ? 403
+      : ["UPLOAD_NOT_FOUND", "FILE_NOT_FOUND"].includes(error.code)
+        ? 404
+        : ["UPLOAD_OFFSET_CONFLICT", "CONCURRENT_UPLOAD"].includes(error.code)
+          ? 409
+          : ["UPLOAD_TOO_LARGE", "PART_TOO_LARGE"].includes(error.code)
+            ? 413
+            : ["UPLOAD_EXPIRED", "FILE_EXPIRED"].includes(error.code)
+              ? 410
+              : error.code === "FILE_CONTENT_MISSING"
+                ? 503
+                : 400;
+  return Response.json(
+    { error: error.code, message: error.message },
+    { status },
+  );
+}
+
+export function object(value: unknown): Record<string, unknown> {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : {};
+}
+
+export function string(value: unknown) {
+  return typeof value === "string" ? value : "";
+}
+
+export function optionalString(value: unknown) {
+  return typeof value === "string" && value ? value : undefined;
+}
+
+export function integer(value: unknown) {
+  return typeof value === "number" && Number.isSafeInteger(value) ? value : -1;
+}
+
+export function nonNegativeInteger(value: unknown) {
+  const parsed = typeof value === "string" ? Number(value) : value;
+  return typeof parsed === "number" &&
+    Number.isSafeInteger(parsed) &&
+    parsed >= 0
+    ? parsed
+    : -1;
+}
+
+export function optionalDate(value: unknown) {
+  if (value === undefined || value === null || value === "") return undefined;
+  if (typeof value !== "string" || Number.isNaN(Date.parse(value))) {
+    throw new UploadError("INVALID_UPLOAD", "文件过期时间无效");
+  }
+  return new Date(value);
+}

package/template/apps/server/src/storage/routes.test.ts

@@ -0,0 +1,288 @@
+import { describe, expect, test } from "bun:test";
+import { createHash } from "node:crypto";
+import {
+  FileService,
+  InMemoryUploadRepository,
+  MemoryBlobStore,
+  UploadService,
+} from "@windy/storage";
+import { createFoundationSnapshot } from "../foundation.js";
+import type { RequestActor } from "../guards.js";
+import { createServerRuntime } from "../runtime.js";
+import type { RouteApp } from "../system/route-types.js";
+import { platformUploadPolicies } from "./runtime.js";
+import { registerStorageRoutes } from "./routes.js";
+
+class FakeRouteApp implements RouteApp {
+  readonly handlers = new Map<string, (context: unknown) => unknown>();
+  get(path: string, handler: (context: unknown) => unknown) {
+    this.handlers.set(`GET ${path}`, handler);
+  }
+  post(path: string, handler: (context: unknown) => unknown) {
+    this.handlers.set(`POST ${path}`, handler);
+  }
+  put(path: string, handler: (context: unknown) => unknown) {
+    this.handlers.set(`PUT ${path}`, handler);
+  }
+  delete(path: string, handler: (context: unknown) => unknown) {
+    this.handlers.set(`DELETE ${path}`, handler);
+  }
+  invoke(method: string, path: string, context: unknown) {
+    const handler = this.handlers.get(`${method} ${path}`);
+    if (!handler) throw new Error(`未注册路由 ${method} ${path}`);
+    return handler(context);
+  }
+}
+
+describe("文件存储路由", () => {
+  test("上传、续传状态、完成与流式下载均经过 Guard 并写审计", async () => {
+    const fixture = await createFixture();
+    const body = new TextEncoder().encode('{"id":1}\n');
+    const created = (await fixture.app.invoke(
+      "POST",
+      "/system/storage/uploads",
+      context(await fixture.guard(), {
+        purpose: "bulk-data",
+        filename: "source.ndjson",
+        mimeType: "application/x-ndjson",
+        expectedByteSize: body.byteLength,
+        expectedSha256: digest(body),
+      }),
+    )) as Response;
+    expect(created.status).toBe(201);
+    const session = (await created.json()) as { id: string };
+
+    const part = (await fixture.app.invoke(
+      "PUT",
+      "/system/storage/uploads/:id/parts/:partNumber",
+      {
+        ...(await rawContext(fixture, session.id, body)),
+        params: { id: session.id, partNumber: "0" },
+      },
+    )) as Response;
+    expect(part.status).toBe(200);
+    await expect(part.json()).resolves.toMatchObject({
+      partNumber: 0,
+      receivedByteSize: body.byteLength,
+    });
+
+    const resumed = (await fixture.app.invoke(
+      "GET",
+      "/system/storage/uploads/:id",
+      context(await fixture.guard(), undefined, { id: session.id }),
+    )) as { receivedByteSize: number; nextPartNumber: number };
+    expect(resumed).toMatchObject({
+      receivedByteSize: body.byteLength,
+      nextPartNumber: 1,
+    });
+
+    const completed = (await fixture.app.invoke(
+      "POST",
+      "/system/storage/uploads/:id/complete",
+      context(await fixture.guard(), undefined, { id: session.id }),
+    )) as Response;
+    expect(completed.status).toBe(201);
+    const file = (await completed.json()) as { id: string };
+    const downloaded = (await fixture.app.invoke(
+      "GET",
+      "/system/storage/files/:id",
+      context(await fixture.guard(), undefined, { id: file.id }),
+    )) as Response;
+    expect(downloaded.headers.get("content-length")).toBe(
+      String(body.byteLength),
+    );
+    expect(downloaded.headers.get("content-disposition")).toContain(
+      "filename*=UTF-8''source.ndjson",
+    );
+    expect(await downloaded.text()).toBe('{"id":1}\n');
+    expect(
+      fixture.runtime.auditSink.list().map(({ action }) => action),
+    ).toEqual(["file.upload.create", "file.upload.complete", "file.download"]);
+  });
+
+  test("只读权限不绕过 Owner；manage 权限可执行受审计的跨 Owner 下载", async () => {
+    const fixture = await createFixture();
+    const file = await storedFile(fixture, "owner_a");
+    const reader = actor("reader", ["system.storage.read"]);
+    const denied = (await fixture.app.invoke(
+      "GET",
+      "/system/storage/files/:id",
+      context(await fixture.actorGuard(reader), undefined, { id: file.id }),
+    )) as Response;
+    expect(denied.status).toBe(403);
+    expect(fixture.runtime.auditSink.list().at(-1)?.action).toBe(
+      "security.denied",
+    );
+
+    const manager = actor("manager", [
+      "system.storage.read",
+      "system.storage.manage",
+    ]);
+    const allowed = (await fixture.app.invoke(
+      "GET",
+      "/system/storage/files/:id",
+      context(await fixture.actorGuard(manager), undefined, { id: file.id }),
+    )) as Response;
+    expect(allowed.status).toBe(200);
+    expect(await allowed.text()).toBe("{}\n");
+    expect(fixture.runtime.auditSink.list().at(-1)?.actor.id).toBe("manager");
+  });
+
+  test("公开文件端点只返回当前品牌引用的 branding-logo", async () => {
+    let publicFileId = "";
+    const fixture = await createFixture(() => publicFileId);
+    const png = Uint8Array.from([137, 80, 78, 71, 13, 10, 26, 10]);
+    const session = await fixture.uploads.create({
+      ownerId: "owner_a",
+      purpose: "branding-logo",
+      filename: "logo.png",
+      mimeType: "image/png",
+      expectedByteSize: png.byteLength,
+    });
+    await fixture.uploads.appendPart({
+      sessionId: session.id,
+      ownerId: "owner_a",
+      partNumber: 0,
+      byteOffset: 0,
+      byteSize: png.byteLength,
+      sha256: digest(png),
+      body: stream(png),
+    });
+    const file = await fixture.uploads.complete(session.id, "owner_a");
+    const anonymous = await fixture.runtime.createGuardContext(
+      new Request("http://localhost/api/platform/files/x"),
+    );
+    const hidden = (await fixture.app.invoke(
+      "GET",
+      "/platform/files/:id",
+      context(anonymous, undefined, { id: file.id }),
+    )) as Response;
+    expect(hidden.status).toBe(404);
+
+    publicFileId = file.id;
+    const visible = (await fixture.app.invoke(
+      "GET",
+      "/platform/files/:id",
+      context(anonymous, undefined, { id: file.id }),
+    )) as Response;
+    expect(visible.status).toBe(200);
+    expect(visible.headers.get("content-type")).toBe("image/png");
+    expect(visible.headers.get("content-disposition")).toContain("inline");
+    expect(new Uint8Array(await visible.arrayBuffer())).toEqual(png);
+  });
+});
+
+async function createFixture(publicFile?: () => string) {
+  const repository = new InMemoryUploadRepository();
+  const blobStore = new MemoryBlobStore();
+  const uploads = new UploadService({
+    repository,
+    blobStore,
+    policies: platformUploadPolicies,
+  });
+  const runtime = createServerRuntime({ WINDY_DEV_ADMIN_TOKEN: "token" });
+  const app = new FakeRouteApp();
+  registerStorageRoutes(
+    app,
+    {
+      uploads,
+      files: new FileService(repository, blobStore),
+      isPublicBrandingFile: async (id) => publicFile?.() === id,
+    },
+    runtime,
+    createFoundationSnapshot().features,
+  );
+  return {
+    app,
+    runtime,
+    uploads,
+    guard: () =>
+      runtime.createGuardContext(
+        new Request("http://localhost/api/system/storage", {
+          headers: { authorization: "Bearer token" },
+        }),
+      ),
+    actorGuard: (value: RequestActor) =>
+      runtime.createGuardContextForActor(
+        new Request("http://localhost/api/system/storage"),
+        value,
+      ),
+  };
+}
+
+async function storedFile(
+  fixture: Awaited<ReturnType<typeof createFixture>>,
+  ownerId: string,
+) {
+  const body = new TextEncoder().encode("{}\n");
+  const session = await fixture.uploads.create({
+    ownerId,
+    purpose: "bulk-data",
+    filename: "data.ndjson",
+    mimeType: "application/x-ndjson",
+    expectedByteSize: body.byteLength,
+  });
+  await fixture.uploads.appendPart({
+    sessionId: session.id,
+    ownerId,
+    partNumber: 0,
+    byteOffset: 0,
+    byteSize: body.byteLength,
+    sha256: digest(body),
+    body: stream(body),
+  });
+  return fixture.uploads.complete(session.id, ownerId);
+}
+
+async function rawContext(
+  fixture: Awaited<ReturnType<typeof createFixture>>,
+  id: string,
+  body: Uint8Array,
+) {
+  return {
+    guardContext: await fixture.guard(),
+    query: {},
+    request: new Request(`http://localhost/api/system/storage/uploads/${id}`, {
+      method: "PUT",
+      headers: {
+        "content-length": String(body.byteLength),
+        "x-upload-offset": "0",
+        "x-content-sha256": digest(body),
+      },
+      body: new TextDecoder().decode(body),
+    }),
+  };
+}
+
+function context(
+  guardContext: Awaited<
+    ReturnType<ReturnType<typeof createServerRuntime>["createGuardContext"]>
+  >,
+  body?: unknown,
+  params: Record<string, string> = {},
+) {
+  return { guardContext, body, params, query: {} };
+}
+
+function actor(id: string, permissionKeys: string[]): RequestActor {
+  return {
+    id,
+    type: "user",
+    name: id,
+    roleCodes: [],
+    permissionKeys,
+  };
+}
+
+function stream(value: Uint8Array) {
+  return new ReadableStream<Uint8Array>({
+    start(controller) {
+      controller.enqueue(value);
+      controller.close();
+    },
+  });
+}
+
+function digest(value: Uint8Array) {
+  return createHash("sha256").update(value).digest("hex");
+}