@shipfox/api-runners 6.0.0 → 7.0.1

package/src/db/capacity-assignments.test.ts

@@ -1,159 +0,0 @@
-import {eq, inArray} from 'drizzle-orm';
-import {assignCapacityBatch} from '#db/capacity-assignments.js';
-import {db} from '#db/db.js';
-import {capacityAssignments} from '#db/schema/capacity-assignments.js';
-import {reservations} from '#db/schema/reservations.js';
-import {providerRunners} from '#db/schema/runner-instances.js';
-
-describe('assignCapacityBatch', () => {
-  let workspaceId: string;
-  let provisionerId: string;
-
-  beforeEach(() => {
-    workspaceId = crypto.randomUUID();
-    provisionerId = crypto.randomUUID();
-  });
-
-  it('assigns compatible live capacity once and returns the same assignment on retry', async () => {
-    const reservation = await createReservation();
-    const capacity = await createCapacity();
-
-    const first = await assignCapacityBatch({
-      provisionerId,
-      reservationId: reservation.id,
-      capacityIds: [capacity.id],
-    });
-    const retry = await assignCapacityBatch({
-      provisionerId,
-      reservationId: reservation.id,
-      capacityIds: [capacity.id],
-    });
-
-    expect(first).toHaveLength(1);
-    expect(retry).toEqual(first);
-    expect(first[0]).toMatchObject({
-      capacityId: capacity.id,
-      reservationId: reservation.id,
-      workspaceId,
-      provisionerId,
-    });
-  });
-
-  it('does not rebind capacity or a reservation under concurrent assignment requests', async () => {
-    const reservation = await createReservation();
-    const firstCapacity = await createCapacity();
-    const secondCapacity = await createCapacity();
-
-    const result = await Promise.allSettled([
-      assignCapacityBatch({
-        provisionerId,
-        reservationId: reservation.id,
-        capacityIds: [firstCapacity.id],
-      }),
-      assignCapacityBatch({
-        provisionerId,
-        reservationId: reservation.id,
-        capacityIds: [secondCapacity.id],
-      }),
-    ]);
-
-    expect(result.filter((entry) => entry.status === 'fulfilled')).toHaveLength(1);
-    const rows = await db()
-      .select()
-      .from(capacityAssignments)
-      .where(eq(capacityAssignments.reservationId, reservation.id));
-    expect(rows).toHaveLength(1);
-  });
-
-  it('consumes each slot in a multi-capacity reservation without rebinding capacity', async () => {
-    const reservation = await createReservation({count: 2});
-    const firstCapacity = await createCapacity();
-    const secondCapacity = await createCapacity();
-
-    const assignments = await assignCapacityBatch({
-      provisionerId,
-      reservationId: reservation.id,
-      capacityIds: [firstCapacity.id, secondCapacity.id],
-    });
-    const retry = await assignCapacityBatch({
-      provisionerId,
-      reservationId: reservation.id,
-      capacityIds: [firstCapacity.id, secondCapacity.id],
-    });
-
-    expect(assignments).toHaveLength(2);
-    expect(retry).toEqual(assignments);
-  });
-
-  it('rejects expired, incompatible, and foreign capacity without consuming it', async () => {
-    const expiredReservation = await createReservation({expiresAt: new Date(Date.now() - 1_000)});
-    const compatibleCapacity = await createCapacity();
-    const incompatibleReservation = await createReservation({requiredLabels: ['gpu']});
-    const foreignCapacity = await createCapacity({provisionerId: crypto.randomUUID()});
-
-    await expect(
-      assignCapacityBatch({
-        provisionerId,
-        reservationId: expiredReservation.id,
-        capacityIds: [compatibleCapacity.id],
-      }),
-    ).rejects.toMatchObject({name: 'ReservationExpiredError'});
-    await expect(
-      assignCapacityBatch({
-        provisionerId,
-        reservationId: incompatibleReservation.id,
-        capacityIds: [compatibleCapacity.id],
-      }),
-    ).rejects.toMatchObject({name: 'CapacityNotAssignableError'});
-    await expect(
-      assignCapacityBatch({
-        provisionerId,
-        reservationId: incompatibleReservation.id,
-        capacityIds: [foreignCapacity.id],
-      }),
-    ).rejects.toMatchObject({name: 'CapacityNotAssignableError'});
-
-    const rows = await db()
-      .select()
-      .from(capacityAssignments)
-      .where(
-        inArray(capacityAssignments.reservationId, [
-          expiredReservation.id,
-          incompatibleReservation.id,
-        ]),
-      );
-    expect(rows).toEqual([]);
-  });
-
-  async function createReservation(overrides: Partial<typeof reservations.$inferInsert> = {}) {
-    const [row] = await db()
-      .insert(reservations)
-      .values({
-        workspaceId,
-        provisionerId,
-        requiredLabels: ['linux'],
-        count: 1,
-        expiresAt: new Date(Date.now() + 60_000),
-        ...overrides,
-      })
-      .returning();
-    if (!row) throw new Error('Reservation insert returned no row');
-    return row;
-  }
-
-  async function createCapacity(overrides: Partial<typeof providerRunners.$inferInsert> = {}) {
-    const [row] = await db()
-      .insert(providerRunners)
-      .values({
-        provisionerId,
-        providerRunnerId: crypto.randomUUID(),
-        labels: ['linux'],
-        state: 'running',
-        reportedAt: new Date(),
-        ...overrides,
-      })
-      .returning();
-    if (!row) throw new Error('Capacity insert returned no row');
-    return row;
-  }
-});

package/src/db/capacity-assignments.ts

@@ -1,116 +0,0 @@
-import {and, eq, inArray, sql} from 'drizzle-orm';
-import type {CapacityAssignment} from '#core/entities/capacity-assignment.js';
-import {
-  CapacityAlreadyAssignedError,
-  CapacityNotAssignableError,
-  ReservationExpiredError,
-  ReservationNotFoundError,
-} from '#core/errors.js';
-import {db} from './db.js';
-import {capacityAssignments, toCapacityAssignment} from './schema/capacity-assignments.js';
-import {reservations} from './schema/reservations.js';
-import {providerRunners} from './schema/runner-instances.js';
-
-export async function assignCapacityBatch(params: {
-  provisionerId: string;
-  reservationId: string;
-  capacityIds: string[];
-}): Promise<CapacityAssignment[]> {
-  return await db().transaction(async (tx) => {
-    const lockKey = [
-      'runners_capacity_assignments',
-      params.provisionerId,
-      params.reservationId,
-    ].join(':');
-    await tx.execute(sql`select pg_advisory_xact_lock(hashtext(${lockKey}))`);
-    for (const capacityId of [...params.capacityIds].sort()) {
-      await tx.execute(
-        sql`select pg_advisory_xact_lock(hashtext(${['runners_capacity_assignments', capacityId].join(':')}))`,
-      );
-    }
-
-    const [reservation] = await tx
-      .select()
-      .from(reservations)
-      .where(
-        and(
-          eq(reservations.id, params.reservationId),
-          eq(reservations.provisionerId, params.provisionerId),
-        ),
-      )
-      .limit(1);
-    if (!reservation) throw new ReservationNotFoundError(params.reservationId);
-    if (reservation.expiresAt <= new Date())
-      throw new ReservationExpiredError(params.reservationId);
-
-    const existing = await tx
-      .select()
-      .from(capacityAssignments)
-      .where(eq(capacityAssignments.reservationId, reservation.id));
-    const existingByCapacityId = new Map(
-      existing.map((assignment) => [assignment.capacityId, assignment]),
-    );
-    const newCapacityIds = params.capacityIds.filter(
-      (capacityId) => !existingByCapacityId.has(capacityId),
-    );
-    if (existing.length + newCapacityIds.length > reservation.count)
-      throw new CapacityNotAssignableError(params.capacityIds[0] ?? '');
-
-    if (newCapacityIds.length === 0) {
-      return params.capacityIds.flatMap((capacityId) => {
-        const assignment = existingByCapacityId.get(capacityId);
-        return assignment ? [toCapacityAssignment(assignment)] : [];
-      });
-    }
-
-    const capacities = await tx
-      .select()
-      .from(providerRunners)
-      .where(
-        and(
-          eq(providerRunners.provisionerId, params.provisionerId),
-          inArray(providerRunners.id, newCapacityIds),
-        ),
-      );
-    if (capacities.length !== newCapacityIds.length)
-      throw new CapacityNotAssignableError(params.capacityIds[0] ?? '');
-    for (const capacity of capacities) {
-      if (capacity.state !== 'starting' && capacity.state !== 'running')
-        throw new CapacityNotAssignableError(capacity.id);
-      if (
-        !capacity.providerRunnerId ||
-        capacity.labels.length === 0 ||
-        !reservation.requiredLabels.every((label) => capacity.labels.includes(label))
-      ) {
-        throw new CapacityNotAssignableError(capacity.id);
-      }
-    }
-
-    const assignedCapacity = await tx
-      .select({capacityId: capacityAssignments.capacityId})
-      .from(capacityAssignments)
-      .where(inArray(capacityAssignments.capacityId, newCapacityIds));
-    if (assignedCapacity.length > 0)
-      throw new CapacityAlreadyAssignedError(assignedCapacity[0]?.capacityId ?? '');
-
-    const inserted = await tx
-      .insert(capacityAssignments)
-      .values(
-        newCapacityIds.map((capacityId) => ({
-          capacityId,
-          reservationId: reservation.id,
-          workspaceId: reservation.workspaceId,
-          provisionerId: params.provisionerId,
-        })),
-      )
-      .returning();
-    const insertedByCapacityId = new Map(
-      inserted.map((assignment) => [assignment.capacityId, assignment]),
-    );
-    return params.capacityIds.flatMap((capacityId) => {
-      const assignment =
-        existingByCapacityId.get(capacityId) ?? insertedByCapacityId.get(capacityId);
-      return assignment ? [toCapacityAssignment(assignment)] : [];
-    });
-  });
-}

package/src/db/schema/capacity-assignments.ts

@@ -1,34 +0,0 @@
-import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';
-import {index, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';
-import type {CapacityAssignment} from '#core/entities/capacity-assignment.js';
-import {pgTable} from './common.js';
-
-export const capacityAssignments = pgTable(
-  'capacity_assignments',
-  {
-    id: uuidv7PrimaryKey(),
-    capacityId: uuid('capacity_id').notNull(),
-    reservationId: uuid('reservation_id').notNull(),
-    workspaceId: uuid('workspace_id').notNull(),
-    provisionerId: uuid('provisioner_id').notNull(),
-    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),
-  },
-  (table) => [
-    uniqueIndex('runners_capacity_assignments_capacity_unique').on(table.capacityId),
-    index('runners_capacity_assignments_reservation_idx').on(table.reservationId),
-    index('runners_capacity_assignments_workspace_idx').on(table.workspaceId),
-  ],
-);
-
-export type CapacityAssignmentDb = typeof capacityAssignments.$inferSelect;
-
-export function toCapacityAssignment(row: CapacityAssignmentDb): CapacityAssignment {
-  return {
-    id: row.id,
-    capacityId: row.capacityId,
-    reservationId: row.reservationId,
-    workspaceId: row.workspaceId,
-    provisionerId: row.provisionerId,
-    createdAt: row.createdAt,
-  };
-}

package/src/presentation/dto/mint-registration-tokens.ts

@@ -1,28 +0,0 @@
-import type {
-  MintedRegistrationTokenDto,
-  MintRegistrationTokensBatchResponseDto,
-  MintRegistrationTokensRunnerInstanceDto,
-} from '@shipfox/api-runners-dto';
-import type {MintEphemeralRegistrationTokensBatchResult} from '#core/ephemeral-registration-tokens.js';
-
-export function toMintRegistrationTokensRunnerInstances(
-  providerRunners: MintRegistrationTokensRunnerInstanceDto[],
-) {
-  return providerRunners.map((runner) => ({providerRunnerId: runner.provider_runner_id}));
-}
-
-export function toMintRegistrationTokensResponseDto(
-  result: MintEphemeralRegistrationTokensBatchResult[],
-): MintRegistrationTokensBatchResponseDto {
-  return {tokens: result.map(toMintedRegistrationTokenDto)};
-}
-
-function toMintedRegistrationTokenDto(
-  result: MintEphemeralRegistrationTokensBatchResult,
-): MintedRegistrationTokenDto {
-  return {
-    provider_runner_id: result.providerRunnerId,
-    registration_token: result.rawToken,
-    expires_at: result.token.expiresAt.toISOString(),
-  };
-}

package/src/presentation/routes/assign-capacity.ts

@@ -1,48 +0,0 @@
-import {requireProvisionerContext} from '@shipfox/api-auth-context';
-import {
-  assignCapacityBatchBodySchema,
-  assignCapacityBatchResponseSchema,
-} from '@shipfox/api-runners-dto';
-import {ClientError, defineRoute} from '@shipfox/node-fastify';
-import {assignCapacityBatch} from '#core/capacity-assignments.js';
-import {
-  CapacityAlreadyAssignedError,
-  CapacityNotAssignableError,
-  ReservationExpiredError,
-  ReservationNotFoundError,
-} from '#core/errors.js';
-
-export const assignCapacityRoute = defineRoute({
-  method: 'POST',
-  path: '/capacity/assignments',
-  description: 'Atomically assign provisioner capacity to a live reservation',
-  schema: {body: assignCapacityBatchBodySchema, response: {200: assignCapacityBatchResponseSchema}},
-  errorHandler: (error) => {
-    if (error instanceof ReservationNotFoundError)
-      throw new ClientError('Reservation not found', 'reservation-not-found', {status: 404});
-    if (error instanceof ReservationExpiredError)
-      throw new ClientError('Reservation has expired', 'reservation-expired', {status: 409});
-    if (
-      error instanceof CapacityAlreadyAssignedError ||
-      error instanceof CapacityNotAssignableError
-    )
-      throw new ClientError('Capacity cannot be assigned', 'capacity-not-assignable', {
-        status: 409,
-      });
-    throw error;
-  },
-  handler: async (request) => {
-    const {provisionerTokenId} = requireProvisionerContext(request);
-    const assignments = await assignCapacityBatch({
-      provisionerId: provisionerTokenId,
-      reservationId: request.body.reservation_id,
-      capacityIds: request.body.capacity_ids,
-    });
-    return {
-      assignments: assignments.map((assignment) => ({
-        capacity_id: assignment.capacityId,
-        assignment_id: assignment.id,
-      })),
-    };
-  },
-});