alepha 0.20.1 → 0.20.2

package/src/api/issues/services/IssueService.ts

@@ -1,264 +0,0 @@
-import { $inject, Alepha } from "alepha";
-import { DateTimeProvider } from "alepha/datetime";
-import { $logger } from "alepha/logger";
-import { $repository, type Page } from "alepha/orm";
-import { BadRequestError } from "alepha/server";
-import { type IssueEntity, issues } from "../entities/issues.ts";
-import type { CreateIssue } from "../schemas/createIssueSchema.ts";
-import { issueConfigAtom } from "../schemas/issueConfigAtom.ts";
-import type { IssueQuery } from "../schemas/issueQuerySchema.ts";
-import type { MyIssueQuery } from "../schemas/myIssueQuerySchema.ts";
-import type { UpdateIssue } from "../schemas/updateIssueSchema.ts";
-
-export class IssueService {
-  protected readonly alepha = $inject(Alepha);
-  protected readonly log = $logger();
-  protected readonly repo = $repository(issues);
-  protected readonly dateTime = $inject(DateTimeProvider);
-
-  // -----------------------------------------------------------------------------------------------------------------
-
-  /**
-   * Get an issue by ID.
-   */
-  public async getById(id: string): Promise<IssueEntity> {
-    return this.repo.getById(id);
-  }
-
-  // -----------------------------------------------------------------------------------------------------------------
-
-  /**
-   * Create a new issue.
-   */
-  public async create(
-    data: CreateIssue,
-    createdBy: { id: string },
-  ): Promise<IssueEntity> {
-    const config = this.alepha.store.get(issueConfigAtom);
-
-    if (!config.enabled) {
-      throw new BadRequestError("Issue submission is disabled");
-    }
-
-    const openCount = await this.repo.count({
-      createdBy: { eq: createdBy.id },
-      status: { inArray: ["open", "assigned"] },
-    });
-
-    if (openCount >= config.maxOpenPerUser) {
-      throw new BadRequestError(
-        `Maximum open issues per user reached (${config.maxOpenPerUser})`,
-      );
-    }
-
-    const entity = await this.repo.create({
-      createdBy: createdBy.id,
-      title: data.title,
-      type: data.type ?? "bug",
-      priority: data.priority ?? "medium",
-      status: "open",
-      description: data.description,
-      pageUrl: data.pageUrl,
-    });
-
-    this.log.info("Issue created", { id: entity.id, createdBy: createdBy.id });
-
-    await this.alepha.events.emit("issue:created", { issue: entity });
-
-    return entity;
-  }
-
-  // -----------------------------------------------------------------------------------------------------------------
-
-  /**
-   * Find issues for the current user.
-   */
-  public async findMine(
-    userId: string,
-    query: MyIssueQuery = {},
-  ): Promise<Page<IssueEntity>> {
-    query.sort ??= "-createdAt";
-
-    const where = this.repo.createQueryWhere();
-    where.createdBy = { eq: userId };
-
-    if (query.status) {
-      where.status = { eq: query.status };
-    }
-
-    return this.repo.paginate(query, { where }, { count: true });
-  }
-
-  // -----------------------------------------------------------------------------------------------------------------
-
-  /**
-   * Find issues with pagination and filtering (admin).
-   */
-  public async find(query: IssueQuery = {}): Promise<Page<IssueEntity>> {
-    query.sort ??= "-createdAt";
-
-    const where = this.repo.createQueryWhere();
-
-    if (query.status) {
-      where.status = { eq: query.status };
-    }
-
-    if (query.type) {
-      where.type = { eq: query.type };
-    }
-
-    if (query.priority) {
-      where.priority = { eq: query.priority };
-    }
-
-    if (query.assigneeId) {
-      where.assigneeId = { eq: query.assigneeId };
-    }
-
-    if (query.search) {
-      where.title = { ilike: `%${query.search}%` };
-    }
-
-    return this.repo.paginate(query, { where }, { count: true });
-  }
-
-  // -----------------------------------------------------------------------------------------------------------------
-
-  /**
-   * Update issue fields (admin).
-   */
-  public async update(id: string, data: UpdateIssue): Promise<IssueEntity> {
-    return this.repo.updateById(id, data);
-  }
-
-  // -----------------------------------------------------------------------------------------------------------------
-
-  /**
-   * Assign an issue to a user.
-   */
-  public async assign(id: string, assigneeId: string): Promise<IssueEntity> {
-    const issue = await this.repo.getById(id);
-
-    if (issue.status !== "open") {
-      throw new BadRequestError(
-        `Cannot assign issue in "${issue.status}" status (must be "open")`,
-      );
-    }
-
-    const updated = await this.repo.updateById(id, {
-      status: "assigned",
-      assigneeId,
-      assignedAt: this.dateTime.nowISOString(),
-    });
-
-    this.log.info("Issue assigned", { id, assigneeId });
-
-    await this.alepha.events.emit("issue:assigned", {
-      issue: updated,
-      assigneeId,
-    });
-
-    return updated;
-  }
-
-  // -----------------------------------------------------------------------------------------------------------------
-
-  /**
-   * Complete an issue with resolution notes.
-   */
-  public async complete(id: string, resolution: string): Promise<IssueEntity> {
-    const issue = await this.repo.getById(id);
-
-    if (issue.status !== "assigned") {
-      throw new BadRequestError(
-        `Cannot complete issue in "${issue.status}" status (must be "assigned")`,
-      );
-    }
-
-    const updated = await this.repo.updateById(id, {
-      status: "completed",
-      resolution,
-      completedAt: this.dateTime.nowISOString(),
-    });
-
-    this.log.info("Issue completed", { id });
-
-    await this.alepha.events.emit("issue:completed", { issue: updated });
-
-    return updated;
-  }
-
-  // -----------------------------------------------------------------------------------------------------------------
-
-  /**
-   * Reopen a completed issue.
-   */
-  public async reopen(id: string, reason: string): Promise<IssueEntity> {
-    const issue = await this.repo.getById(id);
-
-    if (issue.status !== "completed") {
-      throw new BadRequestError(
-        `Cannot reopen issue in "${issue.status}" status (must be "completed")`,
-      );
-    }
-
-    const updated = await this.repo.updateById(id, {
-      status: "open",
-      reopenReason: reason,
-      assigneeId: undefined,
-      assignedAt: undefined,
-      resolution: undefined,
-      completedAt: undefined,
-    });
-
-    this.log.info("Issue reopened", { id, reason });
-
-    await this.alepha.events.emit("issue:reopened", {
-      issue: updated,
-      reason,
-    });
-
-    return updated;
-  }
-
-  // -----------------------------------------------------------------------------------------------------------------
-
-  /**
-   * Archive a completed issue.
-   */
-  public async archive(id: string): Promise<IssueEntity> {
-    const issue = await this.repo.getById(id);
-
-    if (issue.status !== "completed") {
-      throw new BadRequestError(
-        `Cannot archive issue in "${issue.status}" status (must be "completed")`,
-      );
-    }
-
-    const updated = await this.repo.updateById(id, {
-      status: "archived",
-      archivedAt: this.dateTime.nowISOString(),
-    });
-
-    this.log.info("Issue archived", { id });
-
-    await this.alepha.events.emit("issue:archived", { issue: updated });
-
-    return updated;
-  }
-
-  // -----------------------------------------------------------------------------------------------------------------
-
-  /**
-   * Delete an issue.
-   */
-  public async deleteIssue(id: string): Promise<void> {
-    const issue = await this.repo.getById(id);
-
-    await this.repo.deleteById(id);
-
-    this.log.info("Issue deleted", { id });
-
-    await this.alepha.events.emit("issue:deleted", { issue });
-  }
-}

package/src/api/jobs/__tests__/$job-middleware.spec.ts

@@ -1,126 +0,0 @@
-import { Alepha, createMiddleware, t } from "alepha";
-import { $repository } from "alepha/orm";
-import { AlephaOrmPostgres } from "alepha/orm/postgres";
-import { describe, expect, test, vi } from "vitest";
-import { $job, jobExecutionEntity } from "../index.ts";
-
-const $track = (log: string[], tag: string) =>
-  createMiddleware({
-    name: `$track:${tag}`,
-    handler:
-      ({ next }) =>
-      async (...args: any[]) => {
-        log.push(`${tag}:before`);
-        const result = await next(...args);
-        log.push(`${tag}:after`);
-        return result;
-      },
-  });
-
-describe("$job middleware", () => {
-  test("should apply middleware to job handler", async () => {
-    const log: string[] = [];
-
-    class App {
-      repo = $repository(jobExecutionEntity);
-      myJob = $job({
-        schema: t.object({ value: t.text() }),
-        use: [$track(log, "mw")],
-        handler: async () => {
-          log.push("handler");
-        },
-      });
-    }
-
-    const alepha = Alepha.create().with(AlephaOrmPostgres);
-    const app = alepha.inject(App);
-    await alepha.start();
-
-    await app.myJob.push({ value: "test" });
-
-    await vi.waitFor(() => {
-      expect(log).toStrictEqual(["mw:before", "handler", "mw:after"]);
-    });
-  });
-
-  test("should compose multiple middleware in order", async () => {
-    const log: string[] = [];
-
-    class App {
-      repo = $repository(jobExecutionEntity);
-      myJob = $job({
-        schema: t.object({ value: t.text() }),
-        use: [$track(log, "first"), $track(log, "second")],
-        handler: async () => {
-          log.push("handler");
-        },
-      });
-    }
-
-    const alepha = Alepha.create().with(AlephaOrmPostgres);
-    const app = alepha.inject(App);
-    await alepha.start();
-
-    await app.myJob.push({ value: "test" });
-
-    await vi.waitFor(() => {
-      expect(log).toStrictEqual([
-        "first:before",
-        "second:before",
-        "handler",
-        "second:after",
-        "first:after",
-      ]);
-    });
-  });
-
-  test("should work without middleware (no wrapping overhead)", async () => {
-    const handler = vi.fn();
-
-    class App {
-      repo = $repository(jobExecutionEntity);
-      myJob = $job({
-        schema: t.object({ value: t.text() }),
-        handler,
-      });
-    }
-
-    const alepha = Alepha.create().with(AlephaOrmPostgres);
-    const app = alepha.inject(App);
-    await alepha.start();
-
-    await app.myJob.push({ value: "test" });
-
-    await vi.waitFor(() => {
-      expect(handler).toHaveBeenCalledTimes(1);
-    });
-
-    const args = handler.mock.calls[0][0];
-    expect(args.items[0].payload).toEqual({ value: "test" });
-  });
-
-  test("should apply middleware to cron-triggered jobs", async () => {
-    const log: string[] = [];
-
-    class App {
-      repo = $repository(jobExecutionEntity);
-      cronJob = $job({
-        cron: "0 0 * * *",
-        use: [$track(log, "mw")],
-        handler: async () => {
-          log.push("handler");
-        },
-      });
-    }
-
-    const alepha = Alepha.create().with(AlephaOrmPostgres);
-    const app = alepha.inject(App);
-    await alepha.start();
-
-    await app.cronJob.trigger();
-
-    await vi.waitFor(() => {
-      expect(log).toStrictEqual(["mw:before", "handler", "mw:after"]);
-    });
-  });
-});

package/src/api/jobs/__tests__/JobService.spec.ts

@@ -1,31 +0,0 @@
-import { Alepha } from "alepha";
-import { AlephaOrmPostgres } from "alepha/orm/postgres";
-import { describe, it } from "vitest";
-import {
-  testGetStatsEmpty,
-  testGetStatsWithMixedStatuses,
-} from "../services/JobService-tests.ts";
-
-describe("JobService", () => {
-  describe("getStats", () => {
-    it("should return zeroes when no executions exist (sqlite)", async () => {
-      await testGetStatsEmpty(
-        Alepha.create({ env: { DATABASE_URL: "sqlite://:memory:" } }),
-      );
-    });
-    it("should return zeroes when no executions exist (postgres)", async () => {
-      await testGetStatsEmpty(Alepha.create().with(AlephaOrmPostgres));
-    });
-
-    it("should count executions by status (sqlite)", async () => {
-      await testGetStatsWithMixedStatuses(
-        Alepha.create({ env: { DATABASE_URL: "sqlite://:memory:" } }),
-      );
-    });
-    it("should count executions by status (postgres)", async () => {
-      await testGetStatsWithMixedStatuses(
-        Alepha.create().with(AlephaOrmPostgres),
-      );
-    });
-  });
-});

package/src/api/jobs/entities/jobExecutionLogEntity.ts

@@ -1,13 +0,0 @@
-import { type Static, t } from "alepha";
-import { logEntrySchema } from "alepha/logger";
-import { $entity, db } from "alepha/orm";
-
-export const jobExecutionLogEntity = $entity({
-  name: "job_execution_logs",
-  schema: t.object({
-    id: db.primaryKey(t.uuid()),
-    logs: t.array(logEntrySchema),
-  }),
-});
-
-export type JobExecutionLogEntity = Static<typeof jobExecutionLogEntity.schema>;

package/src/api/jobs/schemas/jobActivitySchema.ts

@@ -1,15 +0,0 @@
-import { type Static, t } from "alepha";
-
-export const jobActivityPointSchema = t.object({
-  date: t.text(),
-  completed: t.integer(),
-  failed: t.integer(),
-});
-
-export type JobActivityPoint = Static<typeof jobActivityPointSchema>;
-
-export const jobActivityQuerySchema = t.object({
-  days: t.optional(t.integer({ minimum: 1, maximum: 90 })),
-});
-
-export type JobActivityQuery = Static<typeof jobActivityQuerySchema>;

package/src/api/jobs/schemas/jobCronInfoSchema.ts

@@ -1,22 +0,0 @@
-import { type Static, t } from "alepha";
-
-export const jobCronInfoSchema = t.object({
-  name: t.text(),
-  cron: t.text(),
-  lock: t.boolean(),
-  priority: t.enum(["critical", "high", "normal", "low"]),
-  concurrency: t.integer(),
-  hasSchema: t.boolean(),
-  paused: t.boolean(),
-  lastExecution: t.optional(
-    t.object({
-      id: t.uuid(),
-      status: t.text(),
-      startedAt: t.optional(t.datetime()),
-      completedAt: t.optional(t.datetime()),
-      error: t.optional(t.text()),
-    }),
-  ),
-});
-
-export type JobCronInfo = Static<typeof jobCronInfoSchema>;

package/src/api/jobs/schemas/jobExecutionDetailResourceSchema.ts

@@ -1,20 +0,0 @@
-import { type Static, t } from "alepha";
-import { logEntrySchema } from "alepha/logger";
-import { jobExecutionEntity } from "../entities/jobExecutionEntity.ts";
-import { jobExecutionCanSchema } from "./jobExecutionResourceSchema.ts";
-
-export const jobExecutionDetailResourceSchema = t.extend(
-  jobExecutionEntity.schema,
-  {
-    can: jobExecutionCanSchema,
-    logs: t.optional(t.array(logEntrySchema)),
-  },
-  {
-    title: "JobExecutionDetailResource",
-    description: "A job execution resource with logs.",
-  },
-);
-
-export type JobExecutionDetailResource = Static<
-  typeof jobExecutionDetailResourceSchema
->;

package/src/api/jobs/schemas/jobFailureSchema.ts

@@ -1,9 +0,0 @@
-import { type Static, t } from "alepha";
-
-export const jobFailureSchema = t.object({
-  jobName: t.text(),
-  failures: t.integer(),
-  lastError: t.optional(t.text()),
-});
-
-export type JobFailure = Static<typeof jobFailureSchema>;

package/src/api/jobs/schemas/jobQueueDepthSchema.ts

@@ -1,14 +0,0 @@
-import { type Static, t } from "alepha";
-
-export const jobQueueDepthSchema = t.object({
-  jobName: t.text(),
-  pending: t.integer(),
-  running: t.integer(),
-  scheduled: t.integer(),
-  retrying: t.integer(),
-  dead: t.integer(),
-  concurrency: t.integer(),
-  paused: t.boolean(),
-});
-
-export type JobQueueDepth = Static<typeof jobQueueDepthSchema>;

package/src/api/jobs/schemas/jobStatsSchema.ts

@@ -1,14 +0,0 @@
-import { type Static, t } from "alepha";
-
-export const jobStatsSchema = t.object({
-  registered: t.integer(),
-  running: t.integer(),
-  pending: t.integer(),
-  scheduled: t.integer(),
-  retrying: t.integer(),
-  dead: t.integer(),
-  completed: t.integer(),
-  failed: t.integer(),
-});
-
-export type JobStats = Static<typeof jobStatsSchema>;

package/src/api/jobs/services/JobService-tests.ts

@@ -1,157 +0,0 @@
-import { $inject, type Alepha, t } from "alepha";
-import { $repository } from "alepha/orm";
-import { expect } from "vitest";
-import { jobExecutionEntity } from "../entities/jobExecutionEntity.ts";
-import { $job } from "../primitives/$job.ts";
-import { JobService } from "./JobService.ts";
-
-// =============================================================================
-// testGetStatsEmpty
-// =============================================================================
-
-export const testGetStatsEmpty = async (alepha: Alepha) => {
-  class App {
-    jobService = $inject(JobService);
-    myJob = $job({
-      schema: t.object({ value: t.text() }),
-      handler: async () => {},
-    });
-  }
-
-  const app = alepha.inject(App);
-  await alepha.start();
-
-  const stats = await app.jobService.getStats();
-
-  expect(stats.registered).toBe(1);
-  expect(stats.running).toBe(0);
-  expect(stats.pending).toBe(0);
-  expect(stats.scheduled).toBe(0);
-  expect(stats.retrying).toBe(0);
-  expect(stats.dead).toBe(0);
-  expect(stats.completed).toBe(0);
-  expect(stats.failed).toBe(0);
-};
-
-// =============================================================================
-// testGetStatsWithMixedStatuses
-// =============================================================================
-
-export const testGetStatsWithMixedStatuses = async (alepha: Alepha) => {
-  class App {
-    repo = $repository(jobExecutionEntity);
-    jobService = $inject(JobService);
-    jobA = $job({
-      schema: t.object({ value: t.text() }),
-      handler: async () => {},
-    });
-    jobB = $job({
-      cron: "0 0 * * *",
-      handler: async () => {},
-    });
-  }
-
-  const app = alepha.inject(App);
-  await alepha.start();
-
-  const now = new Date();
-  const oneHourAgo = new Date(now.getTime() - 3_600_000).toISOString();
-  const twoDaysAgo = new Date(now.getTime() - 2 * 86_400_000).toISOString();
-
-  // Create executions with different statuses
-  await app.repo.create({
-    jobName: "App.jobA",
-    status: "running",
-    priority: 2,
-    maxAttempts: 1,
-    attempt: 1,
-    startedAt: oneHourAgo,
-  });
-
-  await app.repo.create({
-    jobName: "App.jobA",
-    status: "pending",
-    priority: 2,
-    maxAttempts: 1,
-  });
-
-  await app.repo.create({
-    jobName: "App.jobA",
-    status: "scheduled",
-    priority: 2,
-    maxAttempts: 1,
-    scheduledAt: oneHourAgo,
-  });
-
-  await app.repo.create({
-    jobName: "App.jobA",
-    status: "retrying",
-    priority: 2,
-    maxAttempts: 3,
-    attempt: 1,
-    scheduledAt: oneHourAgo,
-  });
-
-  await app.repo.create({
-    jobName: "App.jobA",
-    status: "dead",
-    priority: 2,
-    maxAttempts: 1,
-    attempt: 1,
-    error: "boom",
-    completedAt: oneHourAgo,
-  });
-
-  // completed within 24h
-  await app.repo.create({
-    jobName: "App.jobA",
-    status: "completed",
-    priority: 2,
-    maxAttempts: 1,
-    attempt: 1,
-    completedAt: oneHourAgo,
-  });
-
-  // completed outside 24h — should NOT count
-  await app.repo.create({
-    jobName: "App.jobA",
-    status: "completed",
-    priority: 2,
-    maxAttempts: 1,
-    attempt: 1,
-    completedAt: twoDaysAgo,
-  });
-
-  // dead within 24h — should count for failed
-  await app.repo.create({
-    jobName: "App.jobA",
-    status: "dead",
-    priority: 2,
-    maxAttempts: 1,
-    attempt: 1,
-    error: "recent failure",
-    completedAt: oneHourAgo,
-  });
-
-  // dead outside 24h — should NOT count for failed
-  await app.repo.create({
-    jobName: "App.jobA",
-    status: "dead",
-    priority: 2,
-    maxAttempts: 1,
-    attempt: 1,
-    error: "old failure",
-    completedAt: twoDaysAgo,
-  });
-
-  const stats = await app.jobService.getStats();
-
-  expect(stats.registered).toBe(2); // jobA + jobB
-  expect(stats.running).toBe(1);
-  expect(stats.pending).toBe(1);
-  expect(stats.scheduled).toBe(1);
-  expect(stats.retrying).toBe(1);
-  expect(stats.dead).toBe(3); // all dead regardless of time
-  expect(stats.completed).toBe(1); // only the recent one
-  expect(stats.failed).toBe(2); // 2 dead within 24h (the recent dead ones)
-};