offscale/db/queries.ts

import { eq, and, desc } from 'drizzle-orm';
import { db } from 'officerdb/db';
import { offscaleServers } from './schema';
import { encryptSecret, decryptSecret } from 'officerdb/crypto';

// Headscale server registry access for the officer-offscale sidecar. Callers deal in PLAINTEXT —
// encryption to/from at-rest ciphertext happens here, so the sidecar's route handlers never touch crypto.
// See ./schema.ts — the encryption lives in the platform, via officerdb.
//
// Two return types on purpose:
//   OffscaleServer            — safe to serialize to the browser. Has NO api key field at all.
//   OffscaleServerCredentials — url + decrypted key, for the sidecar's own upstream calls. Never returned
//                                by a route handler.
// The `serverCols` projection is what enforces that: `select()` without it would leak the ciphertext column
// into every list response the moment someone forgot to strip it.

export type OffscaleServer = {
  id: number;
  name: string;
  url: string;
  version: string | null;
  sshHost: string | null;
  isActive: boolean;
  lastSeenAt: Date | null;
  createdAt: Date;
};

export type OffscaleServerCredentials = { id: number; name: string; url: string; apiKey: string };

const serverCols = {
  id: offscaleServers.id,
  name: offscaleServers.name,
  url: offscaleServers.url,
  version: offscaleServers.version,
  sshHost: offscaleServers.sshHost,
  isActive: offscaleServers.isActive,
  lastSeenAt: offscaleServers.lastSeenAt,
  createdAt: offscaleServers.createdAt,
};

/** Every server the owner has registered, active first then newest. Never includes the API key. */
export async function listOffscaleServers(userId: number): Promise<OffscaleServer[]> {
  return db
    .select(serverCols)
    .from(offscaleServers)
    .where(eq(offscaleServers.userId, userId))
    .orderBy(desc(offscaleServers.isActive), desc(offscaleServers.createdAt));
}

/** The currently selected server with its key decrypted, or null when none is registered/active. */
export async function getActiveOffscaleCredentials(userId: number): Promise<OffscaleServerCredentials | null> {
  const [row] = await db
    .select()
    .from(offscaleServers)
    .where(and(eq(offscaleServers.userId, userId), eq(offscaleServers.isActive, true)));
  if (!row) return null;
  return { id: row.id, name: row.name, url: row.url, apiKey: decryptSecret('offscale', row.apiKey) };
}

/** One server's credentials by id — for probing a specific server rather than the active one. */
export async function getOffscaleCredentials(userId: number, id: number): Promise<OffscaleServerCredentials | null> {
  const [row] = await db
    .select()
    .from(offscaleServers)
    .where(and(eq(offscaleServers.userId, userId), eq(offscaleServers.id, id)));
  if (!row) return null;
  return { id: row.id, name: row.name, url: row.url, apiKey: decryptSecret('offscale', row.apiKey) };
}

type CreateOffscaleServerParams = {
  userId: number;
  name: string;
  url: string;
  apiKey: string;
  version: string | null;
  /** Optional SSH target for the console. Null when the owner hasn't set one. */
  sshHost: string | null;
  /** Make it the active server. True for the first registration, so the UI is never left with none selected. */
  activate: boolean;
};

/** Register a server. The key is encrypted before write; the returned row carries no key. */
export async function createOffscaleServer(params: CreateOffscaleServerParams): Promise<OffscaleServer> {
  const { userId, name, url, apiKey, version, sshHost, activate } = params;
  return db.transaction(async (tx) => {
    if (activate) {
      await tx
        .update(offscaleServers)
        .set({ isActive: false, updatedAt: new Date() })
        .where(and(eq(offscaleServers.userId, userId), eq(offscaleServers.isActive, true)));
    }
    const [row] = await tx
      .insert(offscaleServers)
      .values({
        userId,
        name,
        url,
        apiKey: encryptSecret('offscale', apiKey),
        version,
        sshHost,
        isActive: activate,
        lastSeenAt: version ? new Date() : null,
      })
      .returning(serverCols);
    return row!;
  });
}

// `sshHost: null` clears the console target; omitting the field leaves it alone. The two must stay
// distinguishable, which is why this is `string | null` and not `string`.
type UpdateOffscaleServerParams = { name?: string; url?: string; apiKey?: string; sshHost?: string | null };

/** Edit a registration. Omitted fields are left alone; a supplied key is re-encrypted. */
export async function updateOffscaleServer(
  userId: number,
  id: number,
  params: UpdateOffscaleServerParams,
): Promise<OffscaleServer | null> {
  const set: Record<string, unknown> = { updatedAt: new Date() };
  if (params.name !== undefined) set.name = params.name;
  if (params.url !== undefined) set.url = params.url;
  if (params.apiKey !== undefined) set.apiKey = encryptSecret('offscale', params.apiKey);
  if (params.sshHost !== undefined) set.sshHost = params.sshHost;

  const [row] = await db
    .update(offscaleServers)
    .set(set)
    .where(and(eq(offscaleServers.userId, userId), eq(offscaleServers.id, id)))
    .returning(serverCols);
  return row ?? null;
}

/** Select a server. Clearing the others first keeps the one-active partial index satisfied. */
export async function setActiveOffscaleServer(userId: number, id: number): Promise<OffscaleServer | null> {
  return db.transaction(async (tx) => {
    await tx
      .update(offscaleServers)
      .set({ isActive: false, updatedAt: new Date() })
      .where(and(eq(offscaleServers.userId, userId), eq(offscaleServers.isActive, true)));
    const [row] = await tx
      .update(offscaleServers)
      .set({ isActive: true, updatedAt: new Date() })
      .where(and(eq(offscaleServers.userId, userId), eq(offscaleServers.id, id)))
      .returning(serverCols);
    return row ?? null;
  });
}

/**
 * Drop a registration. If it was the active one, the newest survivor is promoted — otherwise deleting the
 * active server would leave the UI with servers registered but none selected, which reads as "not
 * configured" and is a confusing place to land.
 */
export async function deleteOffscaleServer(userId: number, id: number): Promise<boolean> {
  return db.transaction(async (tx) => {
    const [deleted] = await tx
      .delete(offscaleServers)
      .where(and(eq(offscaleServers.userId, userId), eq(offscaleServers.id, id)))
      .returning({ id: offscaleServers.id, wasActive: offscaleServers.isActive });
    if (!deleted) return false;

    if (deleted.wasActive) {
      const [next] = await tx
        .select({ id: offscaleServers.id })
        .from(offscaleServers)
        .where(eq(offscaleServers.userId, userId))
        .orderBy(desc(offscaleServers.createdAt))
        .limit(1);
      if (next) {
        await tx
          .update(offscaleServers)
          .set({ isActive: true, updatedAt: new Date() })
          .where(eq(offscaleServers.id, next.id));
      }
    }
    return true;
  });
}

/** Record a successful reachability probe: the version observed and when we last reached the server. */
export async function recordOffscaleProbe(userId: number, id: number, version: string | null): Promise<void> {
  await db
    .update(offscaleServers)
    .set({ version, lastSeenAt: new Date(), updatedAt: new Date() })
    .where(and(eq(offscaleServers.userId, userId), eq(offscaleServers.id, id)));
}