@cartanova/qgrid-cli 2.4.2 → 2.4.4

package/bundle/src/application/qgrid/qgrid.frame.ts

@@ -13,12 +13,8 @@ import {
 } from "../../utils/providers/common/credentials";
 import { MICRO_USD, RequestLogModel } from "../request-log/request-log.model";
 import { type TokenSubsetA } from "../sonamu.generated";
-import { TokenModel } from "../token/token.model";
-import {
-  TokenCredentials,
-  TokenSaveParams,
-  type TokenSaveParams as TokenSaveParamsType,
-} from "../token/token.types";
+import { TokenModel, type TokenUpdateFields } from "../token/token.model";
+import { TokenCredentials } from "../token/token.types";
 import {
   type AnthropicUsageRaw,
   buildAuthUrl,
@@ -404,35 +400,36 @@ class QgridFrameClass extends BaseFrameClass {
     return { added: true };
   }
 
-  @api({ httpMethod: "POST", clients: ["axios", "tanstack-mutation"] })
+  @api({ httpMethod: "POST", clients: ["axios"] })
   async updateToken(
     id: number,
     name?: string,
     quotaThreshold?: number | null,
+    weight?: number,
   ): Promise<{ updated: boolean }> {
-    const entry = await TokenModel.findOne("A", { id });
-    if (!entry) return { updated: false };
-
-    const patch: TokenSaveParamsType = {
-      id: entry.id,
-      provider: entry.provider,
-      credentials: entry.credentials,
-      name: name !== undefined ? name : entry.name,
-    };
-    if (quotaThreshold !== undefined) {
-      patch.quota_threshold = quotaThreshold;
-    }
-
-    const parsed = TokenSaveParams.safeParse(patch);
-    if (!parsed.success) {
+    if (
+      quotaThreshold !== undefined &&
+      quotaThreshold !== null &&
+      (!Number.isInteger(quotaThreshold) || quotaThreshold < 1 || quotaThreshold > 100)
+    ) {
       throw new BadRequestException(
         "quotaThreshold must be an integer between 1 and 100, or null" as LocalizedString,
-        { zodError: parsed.error },
       );
     }
+    if (weight !== undefined && (!Number.isInteger(weight) || weight < 1 || weight > 100)) {
+      throw new BadRequestException(
+        "weight must be an integer between 1 and 100" as LocalizedString,
+      );
+    }
+
+    const patch: TokenUpdateFields = {};
+    if (name !== undefined) patch.name = name;
+    if (quotaThreshold !== undefined) patch.quota_threshold = quotaThreshold;
+    if (weight !== undefined) patch.weight = weight;
+    if (Object.keys(patch).length === 0) return { updated: false };
 
-    await TokenModel.save([parsed.data]);
-    return { updated: true };
+    const updated = await TokenModel.updateFields(id, patch);
+    return { updated: updated > 0 };
   }
 
   @api({ httpMethod: "POST", clients: ["axios", "tanstack-mutation"] })

package/bundle/src/application/qgrid/token-subscriber.test.ts

@@ -22,6 +22,7 @@ function openaiToken(active = true) {
     name: "tok-A",
     credentials: { accessToken: "access", accountId: "account" },
     quota_threshold: 80,
+    weight: 4,
   };
 }
 
@@ -70,9 +71,73 @@ describe("TokenSubscriber OpenAI notifications", () => {
       "tok-A",
       { accessToken: "access", accountId: "account" },
       80,
+      4,
     );
   });
 
+  it("passes weight to Anthropic token updates", async () => {
+    const anthropicDispatcher = { onTokenUpdated: vi.fn() };
+    const subscriber = new TokenSubscriber(
+      {} as never,
+      {
+        removeCache: vi.fn(),
+        upsertCache: vi.fn(),
+        replaceCache: vi.fn(),
+        openaiDispatcher: null,
+        anthropicDispatcher,
+      } as never,
+    );
+    findOneMock.mockResolvedValueOnce({
+      ...openaiToken(true),
+      provider: "anthropic",
+      credentials: { accessToken: "access", refreshToken: "refresh" },
+    });
+
+    await subscriber.handleNotification(JSON.stringify({ op: "UPDATE", id: 1 }));
+
+    expect(anthropicDispatcher.onTokenUpdated).toHaveBeenCalledWith(
+      1,
+      "tok-A",
+      { accessToken: "access", refreshToken: "refresh" },
+      80,
+      4,
+    );
+  });
+
+  it("serializes token reloads so rapid weight updates cannot apply backward", async () => {
+    let resolveFirst!: (value: ReturnType<typeof openaiToken>) => void;
+    const firstRow = new Promise<ReturnType<typeof openaiToken>>((resolve) => {
+      resolveFirst = resolve;
+    });
+    const anthropicDispatcher = { onTokenUpdated: vi.fn() };
+    const subscriber = new TokenSubscriber(
+      {} as never,
+      {
+        removeCache: vi.fn(),
+        upsertCache: vi.fn(),
+        replaceCache: vi.fn(),
+        openaiDispatcher: null,
+        anthropicDispatcher,
+      } as never,
+    );
+    findOneMock.mockReturnValueOnce(firstRow).mockResolvedValueOnce({
+      ...openaiToken(true),
+      provider: "anthropic",
+      weight: 5,
+    });
+
+    const first = subscriber.handleNotification(JSON.stringify({ op: "UPDATE", id: 1 }));
+    const second = subscriber.handleNotification(JSON.stringify({ op: "UPDATE", id: 1 }));
+
+    await flushPromises();
+    expect(findOneMock).toHaveBeenCalledTimes(1);
+
+    resolveFirst({ ...openaiToken(true), provider: "anthropic", weight: 2 });
+    await Promise.all([first, second]);
+
+    expect(anthropicDispatcher.onTokenUpdated.mock.calls.map((call) => call[4])).toEqual([2, 5]);
+  });
+
   it("does not spawn workers for inactive OpenAI inserts", async () => {
     const openaiDispatcher = {
       onTokenAdded: vi.fn(async () => {}),
@@ -86,4 +151,41 @@ describe("TokenSubscriber OpenAI notifications", () => {
     expect(openaiDispatcher.onTokenAdded).not.toHaveBeenCalled();
     expect(openaiDispatcher.onTokenDeactivated).toHaveBeenCalledWith(1);
   });
+
+  it("passes weight while reconciling both provider token pools", async () => {
+    const anthropicDispatcher = { replaceTokens: vi.fn() };
+    const openaiDispatcher = { replaceTokens: vi.fn(async () => {}) };
+    const subscriber = new TokenSubscriber(
+      {} as never,
+      {
+        removeCache: vi.fn(),
+        upsertCache: vi.fn(),
+        replaceCache: vi.fn(),
+        openaiDispatcher,
+        anthropicDispatcher,
+      } as never,
+    );
+    findActiveMock.mockResolvedValueOnce([
+      {
+        ...openaiToken(true),
+        provider: "anthropic",
+        credentials: { accessToken: "access-a", refreshToken: "refresh-a" },
+      },
+      {
+        ...openaiToken(true),
+        id: 2,
+        name: "tok-B",
+        credentials: { accessToken: "access-b", accountId: "account-b" },
+      },
+    ]);
+
+    await subscriber.reconcile();
+
+    expect(anthropicDispatcher.replaceTokens).toHaveBeenCalledWith([
+      expect.objectContaining({ id: 1, quotaThreshold: 80, weight: 4 }),
+    ]);
+    expect(openaiDispatcher.replaceTokens).toHaveBeenCalledWith([
+      expect.objectContaining({ id: 2, quotaThreshold: 80, weight: 4 }),
+    ]);
+  });
 });

package/bundle/src/application/qgrid/token-subscriber.ts

@@ -25,6 +25,7 @@ export class TokenSubscriber {
   attempt = 0;
   connectedAt: Date | null = null;
   lastReconcileAt: Date | null = null;
+  private operationChain: Promise<void> = Promise.resolve();
 
   constructor(
     public connConfig: ClientConfig,
@@ -151,10 +152,14 @@ export class TokenSubscriber {
   }
 
   async handleNotification(payloadJson: string): Promise<void> {
+    return this.enqueueOperation(() => this.handleNotificationNow(payloadJson));
+  }
+
+  private async handleNotificationNow(payloadJson: string): Promise<void> {
     const payload = JSON.parse(payloadJson) as Payload;
     if (payload.op === "DELETE") {
       this.dispatcher.removeCache(payload.id);
-      this.dispatcher.openaiDispatcher
+      await this.dispatcher.openaiDispatcher
         ?.onTokenRemoved(payload.id)
         .catch((e) => logger.warn(`openai worker remove failed: ${(e as Error).message}`));
       // anthropic 토큰 이벤트는 동기(void) — provider 를 모르므로 무해하게 항상 제거 시도.
@@ -165,7 +170,7 @@ export class TokenSubscriber {
     const row = await TokenModel.findOne("A", { id: payload.id });
     if (!row) {
       this.dispatcher.removeCache(payload.id);
-      this.dispatcher.openaiDispatcher
+      await this.dispatcher.openaiDispatcher
         ?.onTokenRemoved(payload.id)
         .catch((e) => logger.warn(`openai worker remove failed: ${(e as Error).message}`));
       this.dispatcher.anthropicDispatcher?.onTokenRemoved(payload.id);
@@ -179,13 +184,25 @@ export class TokenSubscriber {
       const creds = row.credentials as Record<string, unknown>;
       const openaiDispatcher = this.dispatcher.openaiDispatcher;
       if (payload.op === "INSERT" && row.active) {
-        openaiDispatcher
-          ?.onTokenAdded(payload.id, row.name, creds as OpenAICredentials, row.quota_threshold)
+        await openaiDispatcher
+          ?.onTokenAdded(
+            payload.id,
+            row.name,
+            creds as OpenAICredentials,
+            row.quota_threshold,
+            row.weight,
+          )
           .catch((e) => logger.warn(`openai worker spawn failed: ${(e as Error).message}`));
       } else if (row.active) {
         if (openaiDispatcher) {
-          openaiDispatcher
-            .onTokenUpdated(payload.id, row.name, creds as OpenAICredentials, row.quota_threshold)
+          await openaiDispatcher
+            .onTokenUpdated(
+              payload.id,
+              row.name,
+              creds as OpenAICredentials,
+              row.quota_threshold,
+              row.weight,
+            )
             .then(() => openaiDispatcher.onTokenActivated(payload.id))
             .catch((e) => logger.warn(`openai worker update failed: ${(e as Error).message}`));
         }
@@ -203,6 +220,7 @@ export class TokenSubscriber {
           row.name,
           creds,
           row.quota_threshold,
+          row.weight,
         );
       } else if (row.active) {
         this.dispatcher.anthropicDispatcher?.onTokenUpdated(
@@ -210,6 +228,7 @@ export class TokenSubscriber {
           row.name,
           creds,
           row.quota_threshold,
+          row.weight,
         );
       } else {
         // inactive 면 INSERT 든 UPDATE 든 풀에 넣지 않는다.
@@ -220,6 +239,10 @@ export class TokenSubscriber {
   }
 
   async reconcile(): Promise<void> {
+    return this.enqueueOperation(() => this.reconcileNow());
+  }
+
+  private async reconcileNow(): Promise<void> {
     const rows = await TokenModel.findActive("A");
     this.dispatcher.replaceCache(rows);
     // NOTIFY 유실 대비: AnthropicDispatcher 풀도 DB active anthropic 토큰 기준으로 재동기화.
@@ -231,6 +254,7 @@ export class TokenSubscriber {
         name: r.name,
         credentials: r.credentials as AnthropicCredentials,
         quotaThreshold: r.quota_threshold,
+        weight: r.weight,
       }));
     this.dispatcher.anthropicDispatcher?.replaceTokens(anthropicRows);
     const openaiRows = rows
@@ -240,10 +264,17 @@ export class TokenSubscriber {
         name: r.name,
         credentials: r.credentials as OpenAICredentials,
         quotaThreshold: r.quota_threshold,
+        weight: r.weight,
       }));
     await this.dispatcher.openaiDispatcher
       ?.replaceTokens(openaiRows)
       .catch((e) => logger.warn(`openai reconcile failed: ${(e as Error).message}`));
     this.lastReconcileAt = new Date();
   }
+
+  private enqueueOperation(operation: () => Promise<void>): Promise<void> {
+    const next = this.operationChain.then(operation, operation);
+    this.operationChain = next.catch(() => {});
+    return next;
+  }
 }

package/bundle/src/application/qgrid/token-trigger-setup.test.ts

@@ -0,0 +1,9 @@
+import { describe, expect, it } from "vitest";
+
+import { TOKENS_TRIGGER_SETUP_SQL } from "./token-trigger-setup";
+
+describe("tokens trigger setup", () => {
+  it("leaves weight notifications to the versioned migration trigger", () => {
+    expect(TOKENS_TRIGGER_SETUP_SQL).not.toContain("OLD.weight IS DISTINCT FROM NEW.weight");
+  });
+});

package/bundle/src/application/qgrid/token-trigger-setup.ts

@@ -11,7 +11,7 @@ const SETUP_STATEMENT_TIMEOUT_MS = 10_000;
 const ADVISORY_LOCK_CLASS_ID = 717;
 const ADVISORY_LOCK_OBJECT_ID = 44900;
 
-const SETUP_SQL = `
+export const TOKENS_TRIGGER_SETUP_SQL = `
   CREATE OR REPLACE FUNCTION public.tokens_notify() RETURNS trigger
   LANGUAGE plpgsql
   SET search_path = pg_catalog, public
@@ -64,7 +64,7 @@ export async function ensureTokensTrigger(connConfig: ClientConfig): Promise<voi
     ]);
     lockAcquired = true;
 
-    await client.query(SETUP_SQL);
+    await client.query(TOKENS_TRIGGER_SETUP_SQL);
     logger.info("trigger ensured (public.tokens_notify + tokens_changed_* triggers)");
   } finally {
     if (lockAcquired) {

package/bundle/src/application/qgrid/token-weight-migration.test.ts

@@ -0,0 +1,42 @@
+import { type Knex } from "knex";
+import { describe, expect, it, vi } from "vitest";
+
+import { down, up } from "../../migrations/20260710090000_alter_tokens_add_weight";
+
+function fakeKnex() {
+  const raw = vi.fn().mockResolvedValue(undefined);
+  const table = {
+    integer: vi.fn(() => ({
+      notNullable: vi.fn(() => ({ defaultTo: vi.fn() })),
+    })),
+    dropColumns: vi.fn(),
+  };
+  const alterTable = vi.fn(async (_name: string, callback: (value: typeof table) => void) => {
+    callback(table);
+  });
+  return {
+    knex: { raw, schema: { alterTable } } as unknown as Knex,
+    raw,
+  };
+}
+
+describe("tokens weight migration", () => {
+  it("installs a versioned trigger that old bootstrap code cannot replace", async () => {
+    const { knex, raw } = fakeKnex();
+
+    await up(knex);
+
+    expect(raw).toHaveBeenCalledWith(expect.stringContaining("tokens_weight_changed_upd"));
+    expect(raw).toHaveBeenCalledWith(expect.stringContaining("tokens_weight_notify"));
+    expect(raw).toHaveBeenCalledWith(expect.stringContaining("OLD.weight IS DISTINCT FROM NEW.weight"));
+  });
+
+  it("removes the versioned trigger before dropping the weight column", async () => {
+    const { knex, raw } = fakeKnex();
+
+    await down(knex);
+
+    expect(raw).toHaveBeenCalledWith(expect.stringContaining("DROP TRIGGER"));
+    expect(raw).toHaveBeenCalledWith(expect.stringContaining("tokens_weight_changed_upd"));
+  });
+});

package/bundle/src/application/qgrid/tool-emulation.ts

@@ -131,7 +131,12 @@ export function applyToolCallEmulation(
         input: toolCall.args,
       };
     });
-    return { ...result, content: appendImages(content, images), finishReason: "tool-calls", runContext };
+    return {
+      ...result,
+      content: appendImages(content, images),
+      finishReason: "tool-calls",
+      runContext,
+    };
   }
 
   const text = parsed.answer ?? result.text;

package/bundle/src/application/sonamu.generated.http

@@ -40,7 +40,8 @@ Content-Type: application/json
       "name": "NAME",
       "active": false,
       "ord": 0,
-      "quota_threshold": null
+      "quota_threshold": null,
+      "weight": 1
     }
   ]
 }
@@ -441,7 +442,8 @@ Content-Type: application/json
 {
   "id": 0,
   "name": "NAME",
-  "quotaThreshold": null
+  "quotaThreshold": null,
+  "weight": 0
 }
 
 ###

package/bundle/src/application/sonamu.generated.sso.ts

@@ -147,6 +147,7 @@ export const tokenSubsetQueries = {
       active: "tokens.active",
       ord: "tokens.ord",
       quota_threshold: "tokens.quota_threshold",
+      weight: "tokens.weight",
     });
   },
 };

package/bundle/src/application/sonamu.generated.ts

@@ -196,9 +196,17 @@ export const TokenBaseSchema = z.object({
   active: z.boolean(),
   ord: z.int(),
   quota_threshold: z.int().nullable(),
+  weight: z.int(),
 });
 export type TokenBaseSchema = z.infer<typeof TokenBaseSchema> & {
-  readonly __hasDefault__: readonly ["created_at", "active", "ord", "quota_threshold", "id"];
+  readonly __hasDefault__: readonly [
+    "created_at",
+    "active",
+    "ord",
+    "quota_threshold",
+    "weight",
+    "id",
+  ];
 };
 
 // BaseListParams: RequestLog
@@ -372,6 +380,7 @@ export const TokenSubsetA = z.object({
   active: z.boolean(),
   ord: z.int(),
   quota_threshold: z.int().nullable(),
+  weight: z.int(),
 });
 export type TokenSubsetA = z.infer<typeof TokenSubsetA>;
 export type TokenSubsetMapping = {

package/bundle/src/application/token/token.entity.json

@@ -20,11 +20,27 @@
       "type": "integer",
       "nullable": true,
       "desc": "quota 사용률 임계치(%). null이면 미설정"
+    },
+    {
+      "name": "weight",
+      "type": "integer",
+      "desc": "가중 라운드로빈 라우팅 가중치 (1..100)",
+      "dbDefault": "1"
     }
   ],
   "indexes": [],
   "subsets": {
-    "A": ["id", "created_at", "provider", "credentials", "name", "active", "ord", "quota_threshold"]
+    "A": [
+      "id",
+      "created_at",
+      "provider",
+      "credentials",
+      "name",
+      "active",
+      "ord",
+      "quota_threshold",
+      "weight"
+    ]
   },
   "enums": {
     "TokenOrderBy": { "id-desc": "ID최신순", "ord-asc": "순서순" },

package/bundle/src/application/token/token.model.test.ts

@@ -66,4 +66,47 @@ describe("TokenModel.save", () => {
     const saved = ubRegister.mock.calls[0]?.[1];
     expect(saved).not.toHaveProperty("quota_threshold");
   });
+
+  it("applies weight 1 to newly created tokens by default", async () => {
+    const { ubRegister } = mockWritePuri();
+
+    await TokenModel.save([baseToken]);
+
+    expect(ubRegister).toHaveBeenCalledWith(
+      "tokens",
+      expect.objectContaining({ weight: 1 }),
+    );
+  });
+
+  it("preserves an explicit create weight and does not inject weight into updates", async () => {
+    const { ubRegister } = mockWritePuri();
+
+    await TokenModel.save([{ ...baseToken, weight: 4 }, { ...baseToken, id: 1 }]);
+
+    expect(ubRegister.mock.calls[0]?.[1]).toEqual(expect.objectContaining({ weight: 4 }));
+    expect(ubRegister.mock.calls[1]?.[1]).not.toHaveProperty("weight");
+  });
+});
+
+describe("TokenModel.updateFields", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("updates only the supplied columns and returns the affected row count", async () => {
+    const update = vi.fn().mockResolvedValue(1);
+    const where = vi.fn(() => ({ update }));
+    const table = vi.fn(() => ({ where }));
+    const transaction = vi.fn(async (callback: (trx: { table: typeof table }) => Promise<number>) =>
+      callback({ table }),
+    );
+    vi.spyOn(TokenModel as unknown as { getPuri: (mode: "w") => MockPuri }, "getPuri")
+      .mockReturnValue({ transaction } as unknown as MockPuri);
+
+    await expect(TokenModel.updateFields(1, { weight: 4 })).resolves.toBe(1);
+
+    expect(table).toHaveBeenCalledWith("tokens");
+    expect(where).toHaveBeenCalledWith("id", 1);
+    expect(update).toHaveBeenCalledWith({ weight: 4 });
+  });
 });

package/bundle/src/application/token/token.model.ts

@@ -14,10 +14,21 @@ import { tokenLoaderQueries, tokenSubsetQueries } from "../sonamu.generated.sso"
 import { type TokenListParams, type TokenSaveParams } from "./token.types";
 
 const DEFAULT_QUOTA_THRESHOLD = 80;
+const DEFAULT_WEIGHT = 1;
+
+export type TokenUpdateFields = {
+  name?: string;
+  quota_threshold?: number | null;
+  weight?: number;
+};
 
 function applyCreateDefaults(sp: TokenSaveParams): TokenSaveParams {
-  if (sp.id !== undefined || sp.quota_threshold !== undefined) return sp;
-  return { ...sp, quota_threshold: DEFAULT_QUOTA_THRESHOLD };
+  if (sp.id !== undefined) return sp;
+  return {
+    ...sp,
+    ...(sp.quota_threshold === undefined ? { quota_threshold: DEFAULT_QUOTA_THRESHOLD } : {}),
+    ...(sp.weight === undefined ? { weight: DEFAULT_WEIGHT } : {}),
+  };
 }
 
 class TokenModelClass extends BaseModelClass<
@@ -157,6 +168,11 @@ class TokenModelClass extends BaseModelClass<
     });
   }
 
+  async updateFields(id: number, fields: TokenUpdateFields): Promise<number> {
+    const wdb = this.getPuri("w");
+    return wdb.transaction((trx) => trx.table("tokens").where("id", id).update(fields));
+  }
+
   @api({ httpMethod: "POST", clients: ["axios", "tanstack-mutation"] })
   async reorder(ids: number[]): Promise<{ done: boolean }> {
     const wdb = this.getPuri("w");

package/bundle/src/application/token/token.types.test.ts

@@ -31,4 +31,15 @@ describe("TokenSaveParams", () => {
     expect(() => TokenSaveParams.parse({ ...baseToken, quota_threshold: 0 })).toThrow();
     expect(() => TokenSaveParams.parse({ ...baseToken, quota_threshold: 101 })).toThrow();
   });
+
+  it("accepts integer weights from 1 through 100", () => {
+    expect(TokenSaveParams.parse({ ...baseToken, weight: 1 }).weight).toBe(1);
+    expect(TokenSaveParams.parse({ ...baseToken, weight: 100 }).weight).toBe(100);
+  });
+
+  it("rejects invalid weights", () => {
+    for (const weight of [0, 101, 1.5]) {
+      expect(() => TokenSaveParams.parse({ ...baseToken, weight })).toThrow();
+    }
+  });
 });

package/bundle/src/application/token/token.types.ts

@@ -31,6 +31,7 @@ export const TokenListParams = TokenBaseListParams;
 export type TokenListParams = z.infer<typeof TokenListParams>;
 
 const TokenQuotaThreshold = z.int().min(1).max(100).nullable();
+const TokenWeight = z.int().min(1).max(100);
 
 // Token - SaveParams
 export const TokenSaveParams = TokenBaseSchema.partial({
@@ -39,7 +40,9 @@ export const TokenSaveParams = TokenBaseSchema.partial({
   active: true,
   ord: true,
   quota_threshold: true,
+  weight: true,
 }).extend({
   quota_threshold: TokenQuotaThreshold.optional(),
+  weight: TokenWeight.optional(),
 });
 export type TokenSaveParams = z.infer<typeof TokenSaveParams>;

package/bundle/src/i18n/sd.generated.ts

@@ -276,6 +276,7 @@ const entityLabels = {
   "entity.Token.active": "활성 여부",
   "entity.Token.ord": "정렬 순서",
   "entity.Token.quota_threshold": "quota 사용률 임계치(%). null이면 미설정",
+  "entity.Token.weight": "가중 라운드로빈 라우팅 가중치 (1..100)",
   "enum.TokenOrderBy.id-desc": "ID최신순",
   "enum.TokenOrderBy.ord-asc": "순서순",
   "enum.TokenSearchField.id": "ID",

package/bundle/src/index.ts

@@ -1,6 +1,3 @@
-import { Sonamu } from "sonamu";
+import { bootstrapServer } from "./server-bootstrap";
 
-async function bootstrap() {
-  await Sonamu.createServer();
-}
-bootstrap();
+void bootstrapServer();

package/bundle/src/migrations/20260521134025_alter_request_log_steps_alter1.ts

@@ -1,13 +1,9 @@
 import { type Knex } from "knex";
 
-export async function up(knex: Knex): Promise<void> {
-  await knex.raw(
-    `CREATE INDEX request_log_steps_request_log_id_index ON request_log_steps USING btree(request_log_id ASC NULLS LAST);`,
-  );
+export async function up(_knex: Knex): Promise<void> {
+  // The preceding create-table migration already creates this index.
 }
 
-export async function down(knex: Knex): Promise<void> {
-  await knex.schema.alterTable("request_log_steps", (table) => {
-    table.dropIndex(["request_log_id"], "request_log_steps_request_log_id_index");
-  });
+export async function down(_knex: Knex): Promise<void> {
+  // Keep the index owned by the preceding create-table migration.
 }

package/bundle/src/migrations/20260706120000_alter_request_logs_add_image_cost.ts

@@ -1,4 +1,4 @@
-import type { Knex } from "knex";
+import { type Knex } from "knex";
 
 export async function up(knex: Knex): Promise<void> {
   await knex.schema.alterTable("request_logs", (table) => {