alepha 0.20.1 → 0.20.2

package/src/api/issues/__tests__/IssueService.spec.ts

@@ -1,263 +0,0 @@
-import { Alepha } from "alepha";
-import { users } from "alepha/api/users";
-import { $repository } from "alepha/orm";
-import { AlephaOrmPostgres } from "alepha/orm/postgres";
-import { BadRequestError } from "alepha/server";
-import { describe, expect, it } from "vitest";
-import { AlephaApiIssues } from "../index.ts";
-import { issueConfigAtom } from "../schemas/issueConfigAtom.ts";
-import { IssueService } from "../services/IssueService.ts";
-
-class TestRepositories {
-  users = $repository(users);
-}
-
-const setup = async () => {
-  const alepha = Alepha.create({ env: { LOG_LEVEL: "error" } });
-
-  alepha.with(AlephaOrmPostgres);
-  alepha.with(AlephaApiIssues);
-  alepha.with(TestRepositories);
-
-  const service = alepha.inject(IssueService);
-  const repos = alepha.inject(TestRepositories);
-
-  await alepha.start();
-
-  const user = await repos.users.create({
-    email: "test@example.com",
-    roles: [],
-  });
-
-  const admin = await repos.users.create({
-    email: "admin@example.com",
-    roles: ["admin"],
-  });
-
-  return { alepha, service, repos, user, admin };
-};
-
-describe("IssueService", () => {
-  describe("create", () => {
-    it("should create an issue with defaults", async () => {
-      const { service, user } = await setup();
-
-      const issue = await service.create(
-        { title: "Something is broken" },
-        { id: user.id },
-      );
-
-      expect(issue.title).toBe("Something is broken");
-      expect(issue.type).toBe("bug");
-      expect(issue.priority).toBe("medium");
-      expect(issue.status).toBe("open");
-      expect(issue.createdBy).toBe(user.id);
-    });
-
-    it("should create an issue with all fields", async () => {
-      const { service, user } = await setup();
-
-      const issue = await service.create(
-        {
-          title: "Add dark mode",
-          type: "feature",
-          priority: "high",
-          description: "We need dark mode support",
-          pageUrl: "https://example.com/settings",
-        },
-        { id: user.id },
-      );
-
-      expect(issue.type).toBe("feature");
-      expect(issue.priority).toBe("high");
-      expect(issue.description).toBe("We need dark mode support");
-      expect(issue.pageUrl).toBe("https://example.com/settings");
-    });
-
-    it("should reject when max open issues reached", async () => {
-      const { alepha, service, user } = await setup();
-
-      alepha.store.set(issueConfigAtom, {
-        enabled: true,
-        maxOpenPerUser: 1,
-      });
-
-      await service.create({ title: "First" }, { id: user.id });
-
-      await expect(
-        service.create({ title: "Second" }, { id: user.id }),
-      ).rejects.toThrowError(BadRequestError);
-    });
-
-    it("should reject when issues are disabled", async () => {
-      const { alepha, service, user } = await setup();
-
-      alepha.store.set(issueConfigAtom, {
-        enabled: false,
-        maxOpenPerUser: 50,
-      });
-
-      await expect(
-        service.create({ title: "Test" }, { id: user.id }),
-      ).rejects.toThrowError(BadRequestError);
-    });
-  });
-
-  describe("assign", () => {
-    it("should assign an open issue", async () => {
-      const { service, user, admin } = await setup();
-      const issue = await service.create({ title: "Bug" }, { id: user.id });
-
-      const assigned = await service.assign(issue.id, admin.id);
-
-      expect(assigned.status).toBe("assigned");
-      expect(assigned.assigneeId).toBe(admin.id);
-      expect(assigned.assignedAt).toBeDefined();
-    });
-
-    it("should reject assigning a non-open issue", async () => {
-      const { service, user, admin } = await setup();
-      const issue = await service.create({ title: "Bug" }, { id: user.id });
-      await service.assign(issue.id, admin.id);
-
-      await expect(service.assign(issue.id, admin.id)).rejects.toThrowError(
-        BadRequestError,
-      );
-    });
-  });
-
-  describe("complete", () => {
-    it("should complete an assigned issue", async () => {
-      const { service, user, admin } = await setup();
-      const issue = await service.create({ title: "Bug" }, { id: user.id });
-      await service.assign(issue.id, admin.id);
-
-      const completed = await service.complete(issue.id, "Fixed the bug");
-
-      expect(completed.status).toBe("completed");
-      expect(completed.resolution).toBe("Fixed the bug");
-      expect(completed.completedAt).toBeDefined();
-    });
-
-    it("should reject completing a non-assigned issue", async () => {
-      const { service, user } = await setup();
-      const issue = await service.create({ title: "Bug" }, { id: user.id });
-
-      await expect(service.complete(issue.id, "Fixed")).rejects.toThrowError(
-        BadRequestError,
-      );
-    });
-  });
-
-  describe("reopen", () => {
-    it("should reopen a completed issue", async () => {
-      const { service, user, admin } = await setup();
-      const issue = await service.create({ title: "Bug" }, { id: user.id });
-      await service.assign(issue.id, admin.id);
-      await service.complete(issue.id, "Fixed");
-
-      const reopened = await service.reopen(issue.id, "Not actually fixed");
-
-      expect(reopened.status).toBe("open");
-      expect(reopened.reopenReason).toBe("Not actually fixed");
-    });
-
-    it("should reject reopening a non-completed issue", async () => {
-      const { service, user } = await setup();
-      const issue = await service.create({ title: "Bug" }, { id: user.id });
-
-      await expect(service.reopen(issue.id, "Reason")).rejects.toThrowError(
-        BadRequestError,
-      );
-    });
-  });
-
-  describe("archive", () => {
-    it("should archive a completed issue", async () => {
-      const { service, user, admin } = await setup();
-      const issue = await service.create({ title: "Bug" }, { id: user.id });
-      await service.assign(issue.id, admin.id);
-      await service.complete(issue.id, "Fixed");
-
-      const archived = await service.archive(issue.id);
-
-      expect(archived.status).toBe("archived");
-      expect(archived.archivedAt).toBeDefined();
-    });
-
-    it("should reject archiving a non-completed issue", async () => {
-      const { service, user } = await setup();
-      const issue = await service.create({ title: "Bug" }, { id: user.id });
-
-      await expect(service.archive(issue.id)).rejects.toThrowError(
-        BadRequestError,
-      );
-    });
-  });
-
-  describe("find", () => {
-    it("should paginate issues", async () => {
-      const { service, user } = await setup();
-      await service.create({ title: "Bug 1" }, { id: user.id });
-      await service.create({ title: "Bug 2" }, { id: user.id });
-
-      const page = await service.find({ size: 10 });
-
-      expect(page.content.length).toBeGreaterThanOrEqual(2);
-      expect(page.page.totalElements).toBeGreaterThanOrEqual(2);
-    });
-
-    it("should filter by status", async () => {
-      const { service, user, admin } = await setup();
-      await service.create({ title: "Open bug" }, { id: user.id });
-      const bug2 = await service.create(
-        { title: "Assigned bug" },
-        { id: user.id },
-      );
-      await service.assign(bug2.id, admin.id);
-
-      const openOnly = await service.find({ status: "open" });
-
-      for (const issue of openOnly.content) {
-        expect(issue.status).toBe("open");
-      }
-    });
-
-    it("should search by title", async () => {
-      const { service, user } = await setup();
-      await service.create({ title: "Login page broken" }, { id: user.id });
-      await service.create({ title: "Dark mode request" }, { id: user.id });
-
-      const result = await service.find({ search: "Login" });
-
-      expect(result.content.some((i) => i.title === "Login page broken")).toBe(
-        true,
-      );
-    });
-  });
-
-  describe("findMine", () => {
-    it("should return only the user's issues", async () => {
-      const { service, user, admin } = await setup();
-      await service.create({ title: "User bug" }, { id: user.id });
-      await service.create({ title: "Admin bug" }, { id: admin.id });
-
-      const mine = await service.findMine(user.id);
-
-      for (const issue of mine.content) {
-        expect(issue.createdBy).toBe(user.id);
-      }
-    });
-  });
-
-  describe("deleteIssue", () => {
-    it("should delete an issue", async () => {
-      const { service, user } = await setup();
-      const issue = await service.create({ title: "Bug" }, { id: user.id });
-
-      await service.deleteIssue(issue.id);
-
-      await expect(service.getById(issue.id)).rejects.toThrow();
-    });
-  });
-});

package/src/api/issues/controllers/AdminIssueController.ts

@@ -1,149 +0,0 @@
-import { $inject, t } from "alepha";
-import { $secure } from "alepha/security";
-import { $action, okSchema } from "alepha/server";
-import { issueQuerySchema } from "../schemas/issueQuerySchema.ts";
-import { issueResourceSchema } from "../schemas/issueResourceSchema.ts";
-import { updateIssueSchema } from "../schemas/updateIssueSchema.ts";
-import { IssueService } from "../services/IssueService.ts";
-
-export class AdminIssueController {
-  protected readonly url = "/issues";
-  protected readonly group = "admin:issues";
-  protected readonly issueService = $inject(IssueService);
-
-  /**
-   * Find issues with pagination and filtering.
-   */
-  public readonly findIssues = $action({
-    path: this.url,
-    group: this.group,
-    use: [$secure({ permissions: ["admin:issue:read"] })],
-    description: "Find issues with pagination and filtering",
-    schema: {
-      query: issueQuerySchema,
-      response: t.page(issueResourceSchema),
-    },
-    handler: ({ query }) => this.issueService.find(query),
-  });
-
-  /**
-   * Get an issue by ID.
-   */
-  public readonly getIssue = $action({
-    path: `${this.url}/:id`,
-    group: this.group,
-    use: [$secure({ permissions: ["admin:issue:read"] })],
-    description: "Get an issue by ID",
-    schema: {
-      params: t.object({ id: t.uuid() }),
-      response: issueResourceSchema,
-    },
-    handler: ({ params }) => this.issueService.getById(params.id),
-  });
-
-  /**
-   * Update issue fields.
-   */
-  public readonly updateIssue = $action({
-    method: "PATCH",
-    path: `${this.url}/:id`,
-    group: this.group,
-    use: [$secure({ permissions: ["admin:issue:update"] })],
-    description: "Update issue fields",
-    schema: {
-      params: t.object({ id: t.uuid() }),
-      body: updateIssueSchema,
-      response: issueResourceSchema,
-    },
-    handler: ({ params, body }) => this.issueService.update(params.id, body),
-  });
-
-  /**
-   * Assign an issue to a user.
-   */
-  public readonly assignIssue = $action({
-    method: "POST",
-    path: `${this.url}/:id/assign`,
-    group: this.group,
-    use: [$secure({ permissions: ["admin:issue:update"] })],
-    description: "Assign an issue to a user",
-    schema: {
-      params: t.object({ id: t.uuid() }),
-      body: t.object({ assigneeId: t.uuid() }),
-      response: issueResourceSchema,
-    },
-    handler: ({ params, body }) =>
-      this.issueService.assign(params.id, body.assigneeId),
-  });
-
-  /**
-   * Mark an issue as completed.
-   */
-  public readonly completeIssue = $action({
-    method: "POST",
-    path: `${this.url}/:id/complete`,
-    group: this.group,
-    use: [$secure({ permissions: ["admin:issue:update"] })],
-    description: "Mark an issue as completed with resolution notes",
-    schema: {
-      params: t.object({ id: t.uuid() }),
-      body: t.object({ resolution: t.text({ minLength: 1 }) }),
-      response: issueResourceSchema,
-    },
-    handler: ({ params, body }) =>
-      this.issueService.complete(params.id, body.resolution),
-  });
-
-  /**
-   * Reopen a completed issue.
-   */
-  public readonly reopenIssue = $action({
-    method: "POST",
-    path: `${this.url}/:id/reopen`,
-    group: this.group,
-    use: [$secure({ permissions: ["admin:issue:update"] })],
-    description: "Reopen a completed issue with a reason",
-    schema: {
-      params: t.object({ id: t.uuid() }),
-      body: t.object({ reason: t.text({ minLength: 1 }) }),
-      response: issueResourceSchema,
-    },
-    handler: ({ params, body }) =>
-      this.issueService.reopen(params.id, body.reason),
-  });
-
-  /**
-   * Archive a completed issue.
-   */
-  public readonly archiveIssue = $action({
-    method: "POST",
-    path: `${this.url}/:id/archive`,
-    group: this.group,
-    use: [$secure({ permissions: ["admin:issue:update"] })],
-    description: "Archive a completed issue",
-    schema: {
-      params: t.object({ id: t.uuid() }),
-      response: issueResourceSchema,
-    },
-    handler: ({ params }) => this.issueService.archive(params.id),
-  });
-
-  /**
-   * Delete an issue.
-   */
-  public readonly deleteIssue = $action({
-    method: "DELETE",
-    path: `${this.url}/:id`,
-    group: this.group,
-    use: [$secure({ permissions: ["admin:issue:delete"] })],
-    description: "Delete an issue",
-    schema: {
-      params: t.object({ id: t.uuid() }),
-      response: okSchema,
-    },
-    handler: async ({ params }) => {
-      await this.issueService.deleteIssue(params.id);
-      return { ok: true, id: params.id };
-    },
-  });
-}

package/src/api/issues/controllers/IssueController.ts

@@ -1,44 +0,0 @@
-import { $inject, t } from "alepha";
-import { $secure } from "alepha/security";
-import { $action } from "alepha/server";
-import { createIssueSchema } from "../schemas/createIssueSchema.ts";
-import { issueResourceSchema } from "../schemas/issueResourceSchema.ts";
-import { myIssueQuerySchema } from "../schemas/myIssueQuerySchema.ts";
-import { IssueService } from "../services/IssueService.ts";
-
-export class IssueController {
-  protected readonly url = "/issues";
-  protected readonly group = "issues";
-  protected readonly issueService = $inject(IssueService);
-
-  /**
-   * Submit a new issue.
-   */
-  public readonly createIssue = $action({
-    method: "POST",
-    path: this.url,
-    group: this.group,
-    use: [$secure({ permissions: ["issue:create"] })],
-    description: "Submit a new issue",
-    schema: {
-      body: createIssueSchema,
-      response: issueResourceSchema,
-    },
-    handler: ({ body, user }) => this.issueService.create(body, user),
-  });
-
-  /**
-   * List issues for the current user.
-   */
-  public readonly getMyIssues = $action({
-    path: `${this.url}/mine`,
-    group: this.group,
-    use: [$secure({ permissions: ["issue:read"] })],
-    description: "List issues submitted by the current user",
-    schema: {
-      query: myIssueQuerySchema,
-      response: t.page(issueResourceSchema),
-    },
-    handler: ({ query, user }) => this.issueService.findMine(user.id, query),
-  });
-}

package/src/api/issues/entities/issues.ts

@@ -1,49 +0,0 @@
-import { type Static, t } from "alepha";
-import { users } from "alepha/api/users";
-import { $entity, db } from "alepha/orm";
-
-export const issueTypeSchema = t.enum(["bug", "feature", "improvement"], {
-  default: "bug",
-});
-
-export const issuePrioritySchema = t.enum(["low", "medium", "high", "urgent"], {
-  default: "medium",
-});
-
-export const issueStatusSchema = t.enum([
-  "open",
-  "assigned",
-  "completed",
-  "archived",
-]);
-
-export const issues = $entity({
-  name: "issues",
-  schema: t.object({
-    id: db.primaryKey(t.uuid()),
-    version: db.version(),
-    createdAt: db.createdAt(),
-    updatedAt: db.updatedAt(),
-    createdBy: db.ref(t.uuid(), () => users.cols.id, { onDelete: "cascade" }),
-    title: t.text({ maxLength: 255 }),
-    type: db.default(issueTypeSchema, "bug"),
-    priority: db.default(issuePrioritySchema, "medium"),
-    status: db.default(issueStatusSchema, "open"),
-    description: t.optional(t.text({ maxLength: 65535 })),
-    pageUrl: t.optional(t.string({ format: "uri" })),
-    assigneeId: t.optional(db.ref(t.uuid(), () => users.cols.id)),
-    assignedAt: t.optional(t.datetime()),
-    resolution: t.optional(t.text({ maxLength: 65535 })),
-    completedAt: t.optional(t.datetime()),
-    reopenReason: t.optional(t.text({ maxLength: 1024 })),
-    archivedAt: t.optional(t.datetime()),
-  }),
-  indexes: [
-    "status",
-    "createdBy",
-    "assigneeId",
-    { columns: ["type", "status"] },
-  ],
-});
-
-export type IssueEntity = Static<typeof issues.schema>;

package/src/api/issues/index.ts

@@ -1,50 +0,0 @@
-import { $module } from "alepha";
-import { AdminIssueController } from "./controllers/AdminIssueController.ts";
-import { IssueController } from "./controllers/IssueController.ts";
-import { IssueService } from "./services/IssueService.ts";
-
-export * from "./controllers/AdminIssueController.ts";
-export * from "./controllers/IssueController.ts";
-export * from "./entities/issues.ts";
-export * from "./schemas/createIssueSchema.ts";
-export * from "./schemas/issueConfigAtom.ts";
-export * from "./schemas/issueQuerySchema.ts";
-export * from "./schemas/issueResourceSchema.ts";
-export * from "./schemas/myIssueQuerySchema.ts";
-export * from "./schemas/updateIssueSchema.ts";
-export * from "./services/IssueService.ts";
-
-declare module "alepha" {
-  interface Hooks {
-    "issue:created": {
-      issue: import("./entities/issues.ts").IssueEntity;
-    };
-    "issue:assigned": {
-      issue: import("./entities/issues.ts").IssueEntity;
-      assigneeId: string;
-    };
-    "issue:completed": {
-      issue: import("./entities/issues.ts").IssueEntity;
-    };
-    "issue:reopened": {
-      issue: import("./entities/issues.ts").IssueEntity;
-      reason: string;
-    };
-    "issue:archived": {
-      issue: import("./entities/issues.ts").IssueEntity;
-    };
-    "issue:deleted": {
-      issue: import("./entities/issues.ts").IssueEntity;
-    };
-  }
-}
-
-/**
- * Issue tracking module — submit, assign, complete, reopen, and archive issues.
- *
- * @module alepha.api.issues
- */
-export const AlephaApiIssues = $module({
-  name: "alepha.api.issues",
-  services: [IssueService, IssueController, AdminIssueController],
-});

package/src/api/issues/schemas/createIssueSchema.ts

@@ -1,13 +0,0 @@
-import type { Static } from "alepha";
-import { t } from "alepha";
-import { issuePrioritySchema, issueTypeSchema } from "../entities/issues.ts";
-
-export const createIssueSchema = t.object({
-  title: t.text({ maxLength: 255 }),
-  type: t.optional(issueTypeSchema),
-  priority: t.optional(issuePrioritySchema),
-  description: t.optional(t.text({ maxLength: 65535 })),
-  pageUrl: t.optional(t.string({ format: "uri" })),
-});
-
-export type CreateIssue = Static<typeof createIssueSchema>;

package/src/api/issues/schemas/issueConfigAtom.ts

@@ -1,13 +0,0 @@
-import { $atom, t } from "alepha";
-
-export const issueConfigAtom = $atom({
-  name: "alepha.api.issues.config",
-  schema: t.object({
-    enabled: t.boolean(),
-    maxOpenPerUser: t.integer({ minimum: 1, maximum: 1000 }),
-  }),
-  default: {
-    enabled: true,
-    maxOpenPerUser: 50,
-  },
-});

package/src/api/issues/schemas/issueQuerySchema.ts

@@ -1,18 +0,0 @@
-import type { Static } from "alepha";
-import { t } from "alepha";
-import { pageQuerySchema } from "alepha/orm";
-import {
-  issuePrioritySchema,
-  issueStatusSchema,
-  issueTypeSchema,
-} from "../entities/issues.ts";
-
-export const issueQuerySchema = t.extend(pageQuerySchema, {
-  status: t.optional(issueStatusSchema),
-  type: t.optional(issueTypeSchema),
-  priority: t.optional(issuePrioritySchema),
-  assigneeId: t.optional(t.uuid({ description: "Filter by assignee" })),
-  search: t.optional(t.text({ description: "Search in title" })),
-});
-
-export type IssueQuery = Static<typeof issueQuerySchema>;

package/src/api/issues/schemas/issueResourceSchema.ts

@@ -1,6 +0,0 @@
-import type { Static } from "alepha";
-import { issues } from "../entities/issues.ts";
-
-export const issueResourceSchema = issues.schema;
-
-export type IssueResource = Static<typeof issueResourceSchema>;

package/src/api/issues/schemas/myIssueQuerySchema.ts

@@ -1,10 +0,0 @@
-import type { Static } from "alepha";
-import { t } from "alepha";
-import { pageQuerySchema } from "alepha/orm";
-import { issueStatusSchema } from "../entities/issues.ts";
-
-export const myIssueQuerySchema = t.extend(pageQuerySchema, {
-  status: t.optional(issueStatusSchema),
-});
-
-export type MyIssueQuery = Static<typeof myIssueQuerySchema>;

package/src/api/issues/schemas/updateIssueSchema.ts

@@ -1,13 +0,0 @@
-import type { Static } from "alepha";
-import { t } from "alepha";
-import { issuePrioritySchema, issueTypeSchema } from "../entities/issues.ts";
-
-export const updateIssueSchema = t.object({
-  title: t.optional(t.text({ maxLength: 255 })),
-  type: t.optional(issueTypeSchema),
-  priority: t.optional(issuePrioritySchema),
-  description: t.optional(t.text({ maxLength: 65535 })),
-  pageUrl: t.optional(t.string({ format: "uri" })),
-});
-
-export type UpdateIssue = Static<typeof updateIssueSchema>;