sonamu 0.9.19 → 0.10.0

package/src/env.ts

@@ -0,0 +1,123 @@
+import { existsSync, readFileSync } from "fs";
+import path from "path";
+
+import dotenv from "dotenv";
+
+export const SONAMU_ENVIRONMENTS = ["test", "development", "staging", "production"] as const;
+
+export type SonamuEnvironment = (typeof SONAMU_ENVIRONMENTS)[number];
+export type EnvironmentSnapshot = Record<string, string>;
+export type EnvironmentSnapshots = Record<SonamuEnvironment, EnvironmentSnapshot>;
+
+export function isSonamuEnvironment(value: string | undefined): value is SonamuEnvironment {
+  return SONAMU_ENVIRONMENTS.includes(value as SonamuEnvironment);
+}
+
+export function getSonamuEnvironment(env: NodeJS.ProcessEnv = process.env): SonamuEnvironment {
+  const nodeEnv = env.NODE_ENV;
+
+  if (nodeEnv === undefined || nodeEnv === "") {
+    return "development";
+  }
+
+  if (isSonamuEnvironment(nodeEnv)) {
+    return nodeEnv;
+  }
+
+  throw new Error(
+    `Invalid NODE_ENV "${nodeEnv}". Sonamu supports only ${SONAMU_ENVIRONMENTS.join(", ")}.`,
+  );
+}
+
+function readDotenvFile(filePath: string): EnvironmentSnapshot {
+  if (!existsSync(filePath)) {
+    return {};
+  }
+
+  return dotenv.parse(readFileSync(filePath));
+}
+
+function assertEnvironmentDotenvExists(rootPath: string, environment: SonamuEnvironment): void {
+  const commonEnvPath = path.join(rootPath, ".env");
+  const environmentEnvPath = path.join(rootPath, `.env.${environment}`);
+
+  if (!existsSync(commonEnvPath) && !existsSync(environmentEnvPath)) {
+    throw new Error(
+      `Missing Sonamu dotenv file. Create ${commonEnvPath} or ${environmentEnvPath}.`,
+    );
+  }
+}
+
+function removePreloadedCommonDotenvValues(
+  baseEnv: NodeJS.ProcessEnv,
+  commonEnv: EnvironmentSnapshot,
+  environmentEnv: EnvironmentSnapshot,
+): NodeJS.ProcessEnv {
+  const runtimeEnv = { ...baseEnv };
+
+  for (const [key, commonValue] of Object.entries(commonEnv)) {
+    if (environmentEnv[key] !== undefined && runtimeEnv[key] === commonValue) {
+      delete runtimeEnv[key];
+    }
+  }
+
+  return runtimeEnv;
+}
+
+export function readEnvironmentSnapshot(
+  rootPath: string,
+  environment: SonamuEnvironment,
+  baseEnv: NodeJS.ProcessEnv = process.env,
+): EnvironmentSnapshot {
+  assertEnvironmentDotenvExists(rootPath, environment);
+  const commonEnv = readDotenvFile(path.join(rootPath, ".env"));
+  const environmentEnv = readDotenvFile(path.join(rootPath, `.env.${environment}`));
+  const runtimeEnv = removePreloadedCommonDotenvValues(baseEnv, commonEnv, environmentEnv);
+
+  return {
+    ...commonEnv,
+    ...environmentEnv,
+    ...readDotenvFile(path.join(rootPath, ".env.local")),
+    ...runtimeEnv,
+    NODE_ENV: environment,
+  };
+}
+
+export function readAllEnvironmentSnapshots(
+  rootPath: string,
+  baseEnv: NodeJS.ProcessEnv = {},
+): EnvironmentSnapshots {
+  return Object.fromEntries(
+    SONAMU_ENVIRONMENTS.map((environment) => [
+      environment,
+      readEnvironmentSnapshot(rootPath, environment, baseEnv),
+    ]),
+  ) as EnvironmentSnapshots;
+}
+
+export function applyCurrentSnapshotToProcessEnv(rootPath: string): EnvironmentSnapshot {
+  const environment = getSonamuEnvironment();
+  const snapshot = readEnvironmentSnapshot(rootPath, environment);
+
+  for (const [key, value] of Object.entries(snapshot)) {
+    process.env[key] = value;
+  }
+
+  return snapshot;
+}
+
+export function isDevelopmentEnvironment(): boolean {
+  return getSonamuEnvironment() === "development";
+}
+
+export function isStagingEnvironment(): boolean {
+  return getSonamuEnvironment() === "staging";
+}
+
+export function isProductionEnvironment(): boolean {
+  return getSonamuEnvironment() === "production";
+}
+
+export function isTestEnvironment(): boolean {
+  return getSonamuEnvironment() === "test";
+}

package/src/migration/__tests__/migrator.test.ts

@@ -0,0 +1,149 @@
+import { afterEach, describe, expect, it } from "vitest";
+
+import { type SonamuConfig } from "../../api/config";
+import { Sonamu } from "../../api/sonamu";
+import { type SonamuDBConfig, type SonamuDBPreset } from "../../database/db";
+import { setSDConfig } from "../../dict/sd";
+import { Migrator } from "../migrator";
+import { SlackConfirm } from "../slack-confirm";
+
+describe("Migrator environment target filtering", () => {
+  const originalEnv = { ...process.env };
+  const presets: SonamuDBPreset[] = [
+    "test",
+    "fixture",
+    "development",
+    "staging",
+    "production",
+    "test_readonly",
+    "development_readonly",
+    "staging_readonly",
+    "production_readonly",
+  ];
+
+  const dbConfig = Object.fromEntries(
+    presets.map((preset) => [
+      preset,
+      {
+        client: "postgresql",
+        connection: {
+          host: "localhost",
+          database: preset,
+        },
+      },
+    ]),
+  ) as SonamuDBConfig;
+
+  afterEach(() => {
+    for (const key of Object.keys(process.env)) {
+      if (!(key in originalEnv)) {
+        delete process.env[key];
+      }
+    }
+    Object.assign(process.env, originalEnv);
+  });
+
+  const getMigrationTargetKeys = () => {
+    Sonamu.dbConfig = dbConfig;
+    return (
+      new Migrator() as unknown as {
+        getMigrationTargetKeys(): (keyof SonamuDBConfig)[];
+      }
+    ).getMigrationTargetKeys();
+  };
+
+  it("limits migration targets to production on a production server runtime", () => {
+    process.env.NODE_ENV = "production";
+
+    expect(getMigrationTargetKeys()).toEqual(["production"]);
+  });
+
+  it("keeps all writable targets available for local development UI workflows", () => {
+    process.env.NODE_ENV = "development";
+
+    expect(getMigrationTargetKeys()).toEqual([
+      "test",
+      "fixture",
+      "development",
+      "staging",
+      "production",
+    ]);
+  });
+});
+
+describe("SlackConfirm target validation", () => {
+  const presets: SonamuDBPreset[] = [
+    "test",
+    "fixture",
+    "development",
+    "staging",
+    "production",
+    "test_readonly",
+    "development_readonly",
+    "staging_readonly",
+    "production_readonly",
+  ];
+
+  const dbConfig = Object.fromEntries(
+    presets.map((preset) => [
+      preset,
+      {
+        client: "postgresql",
+        connection: {
+          host: "localhost",
+          database: preset,
+        },
+      },
+    ]),
+  ) as SonamuDBConfig;
+
+  const createConfig = (targets: string[]): SonamuConfig =>
+    ({
+      projectName: "sonamu-test",
+      api: {
+        dir: "src",
+        route: {
+          prefix: "/api",
+        },
+      },
+      i18n: {
+        defaultLocale: "ko",
+        supportedLocales: ["ko", "en"],
+      },
+      sync: {
+        targets: [],
+      },
+      database: {},
+      server: {},
+      apiConfig: {
+        contextProvider: (defaultContext) => defaultContext,
+        guardHandler: () => undefined,
+      },
+      slackConfirm: {
+        targets,
+        botToken: "xoxb-test",
+        channelId: "C123",
+      },
+    }) as SonamuConfig;
+
+  it("fails fast when slackConfirm.targets contains an unknown DB key", () => {
+    Sonamu.dbConfig = dbConfig;
+    Sonamu.config = createConfig(["production_old"]);
+    setSDConfig(Sonamu.config.i18n);
+
+    expect(() => new SlackConfirm().isTargetRequiresApproval("production")).toThrow(
+      /Slack Confirm targets/,
+    );
+  });
+
+  it("checks approval requirements only after configured targets match dbConfig keys", () => {
+    Sonamu.dbConfig = dbConfig;
+    Sonamu.config = createConfig(["production"]);
+    setSDConfig(Sonamu.config.i18n);
+
+    const slackConfirm = new SlackConfirm();
+
+    expect(slackConfirm.isTargetRequiresApproval("production")).toBe(true);
+    expect(slackConfirm.isTargetRequiresApproval("staging")).toBe(false);
+  });
+});

package/src/migration/migrator.ts

@@ -12,10 +12,11 @@ import { type SonamuDBConfig } from "../database/db";
 import { createKnexInstance } from "../database/knex";
 import { SD } from "../dict/sd";
 import { EntityManager } from "../entity/entity-manager";
+import { getSonamuEnvironment } from "../env";
 import { ServiceUnavailableException } from "../exceptions/so-exceptions";
 import { Naite } from "../naite/naite";
 import { type GenMigrationCode, type MigrationSet } from "../types/types";
-import { isTest } from "../utils/controller";
+import { isLocal, isTest } from "../utils/controller";
 import { exists } from "../utils/fs-utils";
 import { generateAlterCode, generateCreateCode } from "./code-generation";
 import { getMigrationSetFromEntity } from "./migration-set";
@@ -29,6 +30,32 @@ export type MigrationResult = {
 }[];
 
 export class Migrator {
+  private isMissingMigrationTableError(error: unknown): boolean {
+    if (typeof error !== "object" || error === null) {
+      return false;
+    }
+
+    const maybePostgresError = error as { code?: unknown; message?: unknown };
+    return (
+      maybePostgresError.code === "42P01" &&
+      typeof maybePostgresError.message === "string" &&
+      maybePostgresError.message.includes("knex_migrations")
+    );
+  }
+
+  private getMigrationTargetKeys(): (keyof SonamuDBConfig)[] {
+    const connKeys = Object.keys(Sonamu.dbConfig).filter(
+      (key) => !key.endsWith("_readonly"),
+    ) as (keyof SonamuDBConfig)[];
+
+    if (isLocal()) {
+      return connKeys;
+    }
+
+    const environment = getSonamuEnvironment();
+    return connKeys.filter((key) => key === environment);
+  }
+
   private async runMigrationsSequentially(
     conns: { connKey: keyof SonamuDBConfig; knex: Knex }[],
     action: "apply" | "rollback",
@@ -83,9 +110,7 @@ export class Migrator {
     const codes = await this.getMigrationCodes();
     Naite.t("migrator:getStatus:codes", codes);
 
-    const connKeys = Object.keys(Sonamu.dbConfig).filter(
-      (key) => !key.endsWith("_slave"),
-    ) as (keyof typeof Sonamu.dbConfig)[];
+    const connKeys = this.getMigrationTargetKeys();
 
     let migrationStatusError: string | undefined;
 
@@ -99,6 +124,10 @@ export class Migrator {
             try {
               return await tConn.migrate.status();
             } catch (err) {
+              if (this.isMissingMigrationTableError(err)) {
+                return codes.length;
+              }
+
               console.warn(
                 chalk.yellow(
                   `${connKey}의 마이그레이션 상태를 가져오는 데에 실패하였습니다. 데이터베이스가 올바르게 구성되지 않은 것 같습니다. 확인하시고 다시 시도해주세요.\n시도한 연결 설정:\n${JSON.stringify(knexOptions.connection, null, 2)}\n발생한 에러:\n${err}\n`,
@@ -113,6 +142,10 @@ export class Migrator {
               const [, fdList] = await tConn.migrate.list();
               return fdList.map((fd: { file: string }) => fd.file.replace(".ts", ""));
             } catch (err) {
+              if (this.isMissingMigrationTableError(err)) {
+                return codes.map((code) => code.name);
+              }
+
               migrationStatusError = err instanceof Error ? err.message : String(err);
               return [];
             }
@@ -121,6 +154,10 @@ export class Migrator {
             try {
               return await tConn.migrate.currentVersion();
             } catch (_err) {
+              if (this.isMissingMigrationTableError(_err)) {
+                return "none";
+              }
+
               migrationStatusError = _err instanceof Error ? _err.message : String(_err);
               return "error";
             }
@@ -130,7 +167,7 @@ export class Migrator {
           const connection = knexOptions.connection as Knex.PgConnectionConfig;
 
           return {
-            name: connKey.replace("_master", ""),
+            name: connKey,
             connKey,
             connString: `pg://${connection.user ?? ""}@${connection.host}:${
               connection.port
@@ -193,6 +230,14 @@ export class Migrator {
     Naite.t("migrator:runAction:action", action);
     Naite.t("migrator:runAction:targets", targets);
 
+    const allowedTargets = new Set(this.getMigrationTargetKeys());
+    const disallowedTargets = targets.filter((target) => !allowedTargets.has(target));
+    if (disallowedTargets.length > 0) {
+      throw new Error(
+        `Migration targets are not allowed in NODE_ENV=${getSonamuEnvironment()}: ${disallowedTargets.join(", ")}`,
+      );
+    }
+
     // get uniq knex configs
     const configs = unique(
       targets
@@ -359,9 +404,12 @@ export class Migrator {
     // 조인테이블 포함하여 MigrationSet 배열
     const entitySets: MigrationSet[] = [...entitySetsWithJoinTable, ...joinTables];
 
-    const codes: GenMigrationCode[] = (
-      await Promise.all(
-        entitySets.map(async (entitySet) => {
+    const codes: GenMigrationCode[] = [];
+    const batchSize = 4;
+
+    for (let i = 0; i < entitySets.length; i += batchSize) {
+      const batchCodes = await Promise.all(
+        entitySets.slice(i, i + batchSize).map(async (entitySet) => {
           const dbSet = await PostgreSQLSchemaReader.getMigrationSetFromDB(
             compareDB,
             entitySet.table,
@@ -377,8 +425,10 @@ export class Migrator {
             return await generateAlterCode(entitySet, dbSet, compareDB);
           }
         }),
-      )
-    ).flat();
+      );
+
+      codes.push(...batchCodes.flat());
+    }
 
     // normal 타입이 앞으로, foreign이 뒤로
     codes.sort((codeA, codeB) => {
@@ -402,20 +452,27 @@ export class Migrator {
    * @returns Shadow DB 테스트 결과
    */
   async runShadowTest(): Promise<MigrationResult> {
-    const tdbConn = Sonamu.dbConfig.test.connection as Knex.PgConnectionConfig;
-    const shadowDatabase = `${tdbConn.database}__migration_shadow`;
+    const baseTestConn = Sonamu.dbConfig.test.connection as Knex.PgConnectionConfig;
+    const workerId = process.env.SONAMU_WORKER_DB === "true" ? process.env.VITEST_POOL_ID : null;
+    const templateDatabase =
+      workerId !== null ? `${baseTestConn.database}_${workerId ?? "1"}` : baseTestConn.database;
+    const tdbConn = { ...baseTestConn, database: templateDatabase };
+    const shadowDatabase = `${templateDatabase}__migration_shadow`;
 
     // 테스트 상황에서는 트랜잭션을 초기화하고, 새 데이터베이스 커넥션을 가져와야 함
     if (isTest()) {
       await DB.clearTestTransaction();
-      // 병렬 테스트 모드에서는 worker DB 연결 유지
-      if (process.env.SONAMU_WORKER_DB !== "true") {
-        await DB.destroy();
-      }
+      await DB.destroy();
     }
 
     // 기존 Shadow DB 삭제 후 Shadow DB 생성
-    const tdb = createKnexInstance(Sonamu.dbConfig.test);
+    const tdb = createKnexInstance({
+      ...Sonamu.dbConfig.test,
+      connection: {
+        ...baseTestConn,
+        database: "postgres",
+      },
+    });
     try {
       !isTest() && console.log(chalk.magenta(`${shadowDatabase} 삭제`));
       await tdb.raw(`DROP DATABASE IF EXISTS ${shadowDatabase}`);

package/src/migration/slack-confirm.ts

@@ -25,10 +25,29 @@ export type SlackConfirmPendingResult = {
 export class SlackConfirm {
   private config = Sonamu.config.slackConfirm;
 
+  private validateConfiguredTargets(): void {
+    if (!this.config) {
+      return;
+    }
+
+    const validTargets = Object.keys(Sonamu.dbConfig);
+    const invalidTargets = this.config.targets.filter((target) => !validTargets.includes(target));
+
+    if (invalidTargets.length > 0) {
+      assert.fail(
+        SD("sonamu.error.slackConfirmInvalidTargets")(
+          invalidTargets.join(", "),
+          validTargets.join(", "),
+        ),
+      );
+    }
+  }
+
   /**
    * 설정이 있는지 확인합니다.
    */
   isConfigured(): boolean {
+    this.validateConfiguredTargets();
     return !!(this.config?.botToken && this.config?.channelId);
   }
 
@@ -36,6 +55,7 @@ export class SlackConfirm {
    * 해당 target이 승인 대상인지 확인합니다.
    */
   isTargetRequiresApproval(target: keyof SonamuDBConfig): boolean {
+    this.validateConfiguredTargets();
     return this.config?.targets?.includes(target) ?? false;
   }
 
@@ -98,6 +118,7 @@ export class SlackConfirm {
     requestor?: string,
   ): Promise<{ channel: string; ts: string }> {
     assert(this.config, SD("sonamu.error.slackConfirmNotConfigured"));
+    this.validateConfiguredTargets();
 
     const response = await fetch("https://slack.com/api/chat.postMessage", {
       method: "POST",

package/src/skills/sonamu/database.md

@@ -80,7 +80,7 @@ const fixtureDb = createKnexInstance(Sonamu.dbConfig.fixture);
 const generator = new FixtureGenerator(fixtureDb, fixtureDb, "fixture", EntityManager);
 
 // fixture fetch: production → fixture DB
-const sourceDb = DB.getDB("r"); // production_master
+const sourceDb = DB.getDB("r"); // current NODE_ENV readonly DB
 const fixtureDb = createKnexInstance(Sonamu.dbConfig.fixture);
 const generator = new FixtureGenerator(sourceDb, fixtureDb, "fixture", EntityManager);
 ```

package/src/skills/sonamu/entity-basic.md

@@ -436,6 +436,37 @@ SQL expressions per source column type:
 }
 ```
 
+### Partial index (`where`)
+
+`where` declares a PostgreSQL partial index predicate. Provide a raw SQL condition **without** the `WHERE` keyword; it is appended to the generated `CREATE INDEX`. Works for every index type (`index`, `unique`, `hnsw`, `ivfflat`, pgroonga).
+
+```json
+{
+  "name": "uniq_users_email_active",
+  "type": "unique",
+  "columns": [{ "name": "email" }],
+  "where": "deleted_at IS NULL"
+}
+```
+
+→ `CREATE UNIQUE INDEX uniq_users_email_active ON users (email) WHERE deleted_at IS NULL;`
+(Enforces email uniqueness only among non-deleted rows.)
+
+### `nullsNotDistinct` (unique only)
+
+By default PostgreSQL treats `NULL`s as distinct, so a unique index allows multiple `NULL` rows. Set `nullsNotDistinct: true` to emit `NULLS NOT DISTINCT`, treating `NULL`s as equal (at most one `NULL` allowed).
+
+```json
+{
+  "name": "uniq_accounts_external_id",
+  "type": "unique",
+  "columns": [{ "name": "external_id" }],
+  "nullsNotDistinct": true
+}
+```
+
+→ `CREATE UNIQUE INDEX uniq_accounts_external_id ON accounts (external_id) NULLS NOT DISTINCT;`
+
 ### IMPORTANT: Use the actual DB column name in indexes
 
 **The way FK columns are referenced differs between indexes and subsets. Do not confuse them.**

package/src/skills/sonamu/puri.md

@@ -180,6 +180,28 @@ db.table("orders")
 db.orderBy("created_at", "desc").limit(20).offset(40); // Page 3
 ```
 
+### NULLS position & array form
+
+`orderBy` has two overloads:
+
+1. Single column: `orderBy(column, direction?, nulls?)` — `nulls` is `"first" | "last"`
+2. Array: `orderBy(entries[])` — each entry is a column string, a `Puri.raw*` SQL expression, or an object `{ column, order?, nulls? }`
+
+```typescript
+// Single column with NULLS position
+db.orderBy("published_at", "desc", "last");
+
+// Array form: multiple sort keys, per-key direction and NULLS
+db.orderBy([
+  { column: "is_pinned", order: "desc" },
+  { column: "published_at", order: "desc", nulls: "last" },
+  "title", // bare string defaults to asc
+]);
+
+// Sort by a SQL expression
+db.orderBy([Puri.rawNumber("view_count * 2"), { column: "id", order: "desc" }]);
+```
+
 ## GROUP BY & HAVING
 
 ```typescript

package/src/skills/sonamu/testing-devrunner.md

@@ -343,7 +343,7 @@ export default defineConfig({
 
 ### Activation Conditions
 
-DevRunner is registered in `sonamu.ts` under the condition `isLocal() && config.test?.devRunner?.enabled`. `isLocal()` returns true when the `LR` environment variable is undefined or `"local"` (`controller.ts`). It only works in local development environments and is disabled in remote (production/staging) environments.
+DevRunner is registered in `sonamu.ts` under the condition `isLocal() && config.test?.devRunner?.enabled`. `isLocal()` returns true when `NODE_ENV` is `development` or `test` (`controller.ts`). It works in local development and test environments and is disabled in staging/production environments.
 
 ### Parallel Test DB Flow
 

package/src/skills/sonamu/upsert.md

@@ -1,6 +1,6 @@
 ---
 name: sonamu-upsert
-description: Saving complex relational data with Sonamu UpsertBuilder. ubRegister, ubUpsert, insertOnly, updateBatch patterns, FK ordering, cleanOrphans. Use when saving related data with foreign key dependencies.
+description: Saving complex relational data with Sonamu UpsertBuilder. ubRegister, ubUpsert, ubInsertOnly, ubUpdateBatch, bulk insert/upsert patterns, FK ordering, cleanOrphans. Use when saving related data with foreign key dependencies.
 ---
 
 # UpsertBuilder
@@ -178,15 +178,62 @@ await wdb.transaction(async (trx) => {
 });
 ```
 
-## insertOnly (INSERT Only)
+## Bulk Insert / Bulk Upsert (Large Datasets)
+
+**Principle (same as regular saves):** call `ubRegister` for every row **outside** the transaction, then call only `ubUpsert` / `ubInsertOnly` **inside** the transaction. Split large datasets with `chunkSize`. Calling `ubRegister` inside the transaction is reserved for the special case where a row depends on the real id produced by a preceding `ubUpsert`.
+
+### (a) Bulk insert inside a Model
+
+```typescript
+async createMany(params: PostCreateParams[]): Promise<number[]> {
+  const wdb = this.getPuri("w");
+  params.forEach((p) => wdb.ubRegister("posts", p));
+
+  return wdb.transaction(async (trx) => {
+    return trx.ubInsertOnly("posts", { chunkSize: 5000 });
+  });
+}
+```
+
+### (b) Standalone Puri (seed / batch scripts outside a Model)
+
+Outside a Model there is no `this.getPuri("w")`, so build a `PuriWrapper` directly. Use `DB.getDB("w")` only in this script context — inside Models always use `getPuri("w")`.
+
+```typescript
+import { DB, PuriWrapper, UpsertBuilder } from "sonamu";
+
+const puri = new PuriWrapper(DB.getDB("w"), new UpsertBuilder());
+for (const row of rows) puri.ubRegister("audit_logs", row);
+
+await puri.transaction(async (trx) => {
+  await trx.ubInsertOnly("audit_logs", { chunkSize: 5000 }); // or ubUpsert
+});
+```
+
+### (c) Multiple tables in one transaction (FK order)
+
+Register every table outside the transaction, then upsert parents before children.
+
+```typescript
+const puri = new PuriWrapper(DB.getDB("w"), new UpsertBuilder());
+for (const row of postRows) puri.ubRegister("posts", row);
+for (const row of tagRows) puri.ubRegister("post_tags", row);
+
+await puri.transaction(async (trx) => {
+  await trx.ubInsertOnly("posts", { chunkSize: 5000 }); // parent first
+  await trx.ubInsertOnly("post_tags", { chunkSize: 5000 }); // child next
+});
+```
+
+## ubInsertOnly (INSERT Only)
 
 Perform INSERT without UPDATE:
 
 ```typescript
-await trx.insertOnly("logs", { chunkSize: 1000 });
+await trx.ubInsertOnly("logs", { chunkSize: 1000 });
 ```
 
-## updateBatch (Batch Update)
+## ubUpdateBatch (Batch Update)
 
 Bulk UPDATE operations:
 
@@ -197,14 +244,14 @@ wdb.ubRegister("users", { id: 2, status: "active" });
 wdb.ubRegister("users", { id: 3, status: "inactive" });
 
 await wdb.transaction(async (trx) => {
-  await trx.updateBatch("users", {
+  await trx.ubUpdateBatch("users", {
     chunkSize: 500, // batch size (default: 500)
     where: "id", // WHERE condition column (default: "id")
   });
 });
 
 // Composite key for WHERE condition
-await trx.updateBatch("user_settings", {
+await trx.ubUpdateBatch("user_settings", {
   where: ["user_id", "setting_key"],
 });
 ```

package/src/stream/ws-telemetry-memory.ts

@@ -40,8 +40,8 @@ class InMemoryRingBuffer<TRecord extends { timestamp: number }> {
     this.capacity = options.maxRecords ?? DEFAULT_MAX_RECORDS;
     this.maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
     this.estimateBytes = estimateBytes;
-    this.slots = new Array(this.capacity);
-    this.slotBytes = new Array(this.capacity).fill(0);
+    this.slots = Array.from({ length: this.capacity });
+    this.slotBytes = Array.from({ length: this.capacity }, () => 0);
   }
 
   push(record: TRecord): void {