alepha 0.21.2 → 0.22.0

package/src/api/audits/services/AuditService.ts

@@ -56,6 +56,20 @@ export class AuditService {
     return Array.from(this.auditTypes.values());
   }
 
+  /**
+   * Distinct action names across all registered audit types, sorted.
+   *
+   * Sourced from the `$audit` type registry. Audit types register lazily —
+   * when their holder (e.g. `SessionAudits`, `ParameterAudits`) is first
+   * injected — so the admin filter only lists actions for audit domains that
+   * are actually in use, which is the intended behaviour.
+   */
+  public getDistinctActions(): string[] {
+    return [
+      ...new Set(this.getRegisteredTypes().flatMap((type) => type.actions)),
+    ].sort();
+  }
+
   /**
    * Get current request context if available.
    */
@@ -108,11 +122,16 @@ export class AuditService {
       userId: data.userId ?? contextData.userId,
     });
 
+    const success = data.success ?? true;
     const entry = await this.repo.create({
       ...contextData,
       ...data,
-      severity: data.severity ?? "info",
-      success: data.success ?? true,
+      // Outcome drives severity: a failed audit (success:false) defaults to
+      // `warning`, otherwise `info`. Explicit `severity` always wins. This is
+      // the single place the OK/Failed → severity rule lives, so holders and
+      // `$audit` primitives don't repeat it.
+      severity: data.severity ?? (success ? "info" : "warning"),
+      success,
     });
 
     this.log.debug("Audit entry created", {
@@ -135,92 +154,6 @@ export class AuditService {
     return this.create({ type, action, ...options });
   }
 
-  /**
-   * Record an authentication event.
-   */
-  public async recordAuth(
-    action:
-      | "login"
-      | "logout"
-      | "login_failed"
-      | "token_refresh"
-      | "mfa_setup"
-      | "mfa_verify",
-    options: Omit<CreateAudit, "type" | "action"> = {},
-  ): Promise<AuditEntity> {
-    return this.create({
-      type: "auth",
-      action,
-      severity: action === "login_failed" ? "warning" : "info",
-      ...options,
-    });
-  }
-
-  /**
-   * Record a user management event.
-   */
-  public async recordUser(
-    action:
-      | "create"
-      | "update"
-      | "delete"
-      | "enable"
-      | "disable"
-      | "role_change",
-    options: Omit<CreateAudit, "type" | "action"> = {},
-  ): Promise<AuditEntity> {
-    return this.create({
-      type: "user",
-      action,
-      resourceType: "user",
-      ...options,
-    });
-  }
-
-  /**
-   * Record a data access event.
-   */
-  public async recordAccess(
-    action: "view" | "export" | "download",
-    options: Omit<CreateAudit, "type" | "action"> = {},
-  ): Promise<AuditEntity> {
-    return this.create({ type: "access", action, ...options });
-  }
-
-  /**
-   * Record a security event.
-   */
-  public async recordSecurity(
-    action:
-      | "permission_denied"
-      | "suspicious_activity"
-      | "rate_limited"
-      | "blocked",
-    options: Omit<CreateAudit, "type" | "action"> = {},
-  ): Promise<AuditEntity> {
-    return this.create({
-      type: "security",
-      action,
-      severity: "warning",
-      ...options,
-    });
-  }
-
-  /**
-   * Record a system event.
-   */
-  public async recordSystem(
-    action: "startup" | "shutdown" | "config_change" | "maintenance" | "error",
-    options: Omit<CreateAudit, "type" | "action"> = {},
-  ): Promise<AuditEntity> {
-    return this.create({
-      type: "system",
-      action,
-      severity: action === "error" ? "critical" : "info",
-      ...options,
-    });
-  }
-
   /**
    * Find audit entries with filtering and pagination.
    */

package/src/api/files/__tests__/FileService.spec.ts

@@ -1,4 +1,5 @@
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
+import { Readable } from "node:stream";
 import { Alepha, type Service } from "alepha";
 import {
   $bucket,
@@ -6,11 +7,13 @@ import {
   LocalFileStorageProvider,
   MemoryFileStorageProvider,
 } from "alepha/bucket";
+import { $repository } from "alepha/orm";
 import { AlephaOrmPostgres } from "alepha/orm/postgres";
 import type { UserAccountToken } from "alepha/security";
 import { FileSystemProvider } from "alepha/system";
 import { describe, expect, it } from "vitest";
-import { AlephaApiFiles, FileController } from "../index.ts";
+import { users } from "../../users/entities/users.ts";
+import { AlephaApiFiles, FileController, FileService } from "../index.ts";
 
 const adminUser: UserAccountToken = {
   id: "00000000-0000-0000-0000-000000000001",
@@ -128,4 +131,206 @@ describe("FileService", () => {
   it("should handle basic file operations with local storage", async () => {
     await testFileServiceOperations(LocalFileStorageProvider);
   });
+
+  it("removes the orphaned blob when uploadFile's metadata write fails", async () => {
+    const alepha = Alepha.create()
+      .with(AlephaOrmPostgres)
+      .with({ provide: FileStorageProvider, use: MemoryFileStorageProvider })
+      .with(AlephaApiFiles);
+
+    class Assets {
+      images = $bucket({ name: randomUUID() });
+    }
+
+    const assets = alepha.inject(Assets);
+    const service = alepha.inject(FileService);
+    const fs = alepha.inject(FileSystemProvider);
+
+    await alepha.start();
+
+    // An invalid UUID the `creator` column rejects, forcing the metadata
+    // insert to fail *after* the blob has already been written to storage.
+    const brokenUser = {
+      id: "not-a-valid-uuid",
+      name: "Broken",
+    } as UserAccountToken;
+
+    await expect(
+      service.uploadFile(
+        fs.createFile({
+          text: "orphan",
+          name: "orphan.txt",
+          type: "text/plain",
+        }),
+        { bucket: assets.images.name, user: brokenUser },
+      ),
+    ).rejects.toThrow();
+
+    // The blob must not be left behind in the bucket.
+    expect(await assets.images.list()).toEqual([]);
+  });
+
+  it("removes the orphaned blob when the upload hook's metadata write fails", async () => {
+    const alepha = Alepha.create()
+      .with(AlephaOrmPostgres)
+      .with({ provide: FileStorageProvider, use: MemoryFileStorageProvider })
+      .with(AlephaApiFiles);
+
+    class Assets {
+      images = $bucket({ name: randomUUID() });
+    }
+
+    const assets = alepha.inject(Assets);
+    const fs = alepha.inject(FileSystemProvider);
+
+    await alepha.start();
+
+    const brokenUser = {
+      id: "not-a-valid-uuid",
+      name: "Broken",
+    } as UserAccountToken;
+
+    // Direct bucket.upload (persist defaults to true) drives the
+    // `bucket:file:uploaded` hook, whose metadata insert fails on the
+    // invalid creator UUID after the blob is stored.
+    await expect(
+      assets.images.upload(
+        fs.createFile({
+          text: "orphan",
+          name: "orphan.txt",
+          type: "text/plain",
+        }),
+        { user: brokenUser },
+      ),
+    ).rejects.toThrow();
+
+    expect(await assets.images.list()).toEqual([]);
+  });
+
+  it("uploadFile reads a stream-backed file once (no empty blob, real size)", async () => {
+    const alepha = Alepha.create()
+      .with(AlephaOrmPostgres)
+      .with({ provide: FileStorageProvider, use: MemoryFileStorageProvider })
+      .with(AlephaApiFiles);
+
+    class Assets {
+      images = $bucket({ name: randomUUID() });
+    }
+
+    const assets = alepha.inject(Assets);
+    const service = alepha.inject(FileService);
+    const fs = alepha.inject(FileSystemProvider);
+
+    await alepha.start();
+
+    const content = "streamed upload content";
+
+    // A one-shot stream: it can only be read once. The old code drained it
+    // for the checksum before bucket.upload re-read it, storing an empty blob.
+    const file = fs.createFile({
+      stream: Readable.from(Buffer.from(content)),
+      name: "stream.txt",
+      type: "text/plain",
+    });
+
+    const entity = await service.uploadFile(file, {
+      bucket: assets.images.name,
+    });
+
+    // Content must survive (not an empty blob), size must be the real length.
+    expect(entity.size).toBe(content.length);
+    expect(entity.checksum).toBe(
+      createHash("sha256").update(content).digest("hex"),
+    );
+
+    const back = await service.streamFile(entity);
+    expect(await back.text()).toBe(content);
+  });
+
+  it("upload hook reads a stream-backed file once (real size + checksum)", async () => {
+    const alepha = Alepha.create()
+      .with(AlephaOrmPostgres)
+      .with({ provide: FileStorageProvider, use: MemoryFileStorageProvider })
+      .with(AlephaApiFiles);
+
+    class Assets {
+      images = $bucket({ name: randomUUID() });
+    }
+
+    const assets = alepha.inject(Assets);
+    const ctrl = alepha.inject(FileController);
+    const fs = alepha.inject(FileSystemProvider);
+
+    await alepha.start();
+
+    const content = "streamed hook content";
+
+    // Direct bucket.upload (persist defaults to true) → the bucket:file:uploaded
+    // hook persists the row. The hook runs *after* the provider read the stream,
+    // so without materializing first it would checksum an already-drained
+    // (empty) stream and record size 0.
+    await assets.images.upload(
+      fs.createFile({
+        stream: Readable.from(Buffer.from(content)),
+        name: "hook.txt",
+        type: "text/plain",
+      }),
+      { user: adminUser },
+    );
+
+    const files = await ctrl.findFiles.run({}, asAdmin);
+    expect(files.content).toHaveLength(1);
+
+    const entity = files.content[0];
+    expect(entity.size).toBe(content.length);
+    expect(entity.checksum).toBe(
+      createHash("sha256").update(content).digest("hex"),
+    );
+  });
+
+  it("embeds the uploader summary when a users repository is registered", async () => {
+    // Registering a users repository is what flips the best-effort join on
+    // (and creates the `users` table). Without it, the prior tests confirm
+    // findFiles still works and simply leaves `user` undefined.
+    class TestUsers {
+      repo = $repository(users);
+    }
+
+    const alepha = Alepha.create()
+      .with(AlephaOrmPostgres)
+      .with({ provide: FileStorageProvider, use: MemoryFileStorageProvider })
+      .with(AlephaApiFiles);
+
+    const testUsers = alepha.inject(TestUsers);
+    const ctrl = alepha.inject(FileController);
+    const fs = alepha.inject(FileSystemProvider);
+
+    await alepha.start();
+
+    await testUsers.repo.create({
+      id: adminUser.id,
+      email: "uploader@example.com",
+      username: "uploader",
+    });
+
+    await ctrl.uploadFile.run(
+      {
+        body: {
+          file: fs.createFile({
+            text: "joined",
+            name: "joined.txt",
+            type: "text/plain",
+          }),
+        },
+      },
+      asAdmin,
+    );
+
+    const files = await ctrl.findFiles.run({}, asAdmin);
+
+    expect(files.content).toHaveLength(1);
+    expect(files.content[0].creator).toBe(adminUser.id);
+    expect(files.content[0].user?.email).toBe("uploader@example.com");
+    expect(files.content[0].user?.username).toBe("uploader");
+  });
 });

package/src/api/files/index.ts

@@ -16,6 +16,9 @@ export * from "./controllers/FileController.ts";
 export * from "./entities/files.ts";
 export * from "./jobs/FileJobs.ts";
 export * from "./providers/FileAccessProvider.ts";
+export * from "./schemas/fileCreatorSummarySchema.ts";
+export * from "./schemas/fileQuerySchema.ts";
+export * from "./schemas/fileResourceSchema.ts";
 export * from "./schemas/storageStatsSchema.ts";
 export * from "./services/FileService.ts";
 

package/src/api/files/schemas/fileCreatorSummarySchema.ts

@@ -0,0 +1,22 @@
+import { type Static, t } from "alepha";
+
+/**
+ * Slim view of a file's uploader, embedded by the admin listing via a
+ * best-effort left join (`files.creator` → `users.id`) so the UI can render
+ * a human-readable identifier instead of a bare UUID.
+ *
+ * Optional end-to-end: the join only runs when the `users` entity is
+ * registered in the running app (see `FileService.findFiles`), and even then
+ * a file whose creator was deleted — or who lives in a non-default realm —
+ * comes back with `user` undefined. Callers must fall back to `creatorName`
+ * or the raw `creator` id.
+ */
+export const fileCreatorSummarySchema = t.object({
+  id: t.uuid(),
+  email: t.optional(t.string({ format: "email" })),
+  username: t.optional(t.shortText({ minLength: 3, maxLength: 30 })),
+  firstName: t.optional(t.string()),
+  lastName: t.optional(t.string()),
+});
+
+export type FileCreatorSummary = Static<typeof fileCreatorSummarySchema>;

package/src/api/files/schemas/fileResourceSchema.ts

@@ -1,9 +1,18 @@
 import { type Static, t } from "alepha";
 import { files } from "../entities/files.ts";
+import { fileCreatorSummarySchema } from "./fileCreatorSummarySchema.ts";
 
 export const fileResourceSchema = t.extend(
   files.schema,
-  {},
+  {
+    /**
+     * Uploader summary, embedded by the admin listing via a best-effort
+     * left join. Optional — see `fileCreatorSummarySchema`. Distinct from
+     * the denormalized `creatorName`, which is set only on direct uploads
+     * and never carries an email.
+     */
+    user: t.optional(fileCreatorSummarySchema),
+  },
   {
     title: "FileResource",
     description: "A file resource representing a file stored in the system.",