sonamu 0.7.21 → 0.7.23

package/src/template/implementations/view_search_input.template.ts

@@ -20,44 +20,60 @@ export class Template__view_search_input extends Template {
     return {
       ...this.getTargetAndPath(names),
       body: `
-import React from "react";
+import { Button, Input } from "@sonamu-kit/react-components/components";
+import type React from "react";
 import { useState } from "react";
-import { DropdownProps, Input, InputProps } from "semantic-ui-react";
-import { ${names.capital}SearchFieldDropdown } from "@/components/${names.fs}/${names.capital}SearchFieldDropdown";
+import { ${names.capital}SearchFieldSelect } from "@/components/${names.fs}/${names.capital}SearchFieldSelect";
+import SearchIcon from "~icons/lucide/search";
+
+export type ${names.capital}SearchInputProps = {
+  input: {
+    value?: string;
+    onChange?: (e: React.ChangeEvent<HTMLInputElement>) => void;
+  };
+  dropdown: {
+    value?: string;
+    onChange?: (e: React.ChangeEvent<HTMLSelectElement>) => void;
+  };
+};
 
 export function ${names.capital}SearchInput({
-  input: { value: inputValue, onChange: inputOnChange, ...inputProps },
+  input: { value: inputValue, onChange: inputOnChange },
   dropdown: dropdownProps,
-}: {
-  input: InputProps;
-  dropdown: DropdownProps;
-}) {
-  const [keyword, setKeyword] = useState<string>(inputValue ?? '');
+}: ${names.capital}SearchInputProps) {
+  const [keyword, setKeyword] = useState<string>(inputValue ?? "");
+
+  const handleSearch = () => {
+    if (inputOnChange) {
+      const syntheticEvent = {
+        target: { value: keyword },
+        currentTarget: { value: keyword },
+      } as React.ChangeEvent<HTMLInputElement>;
+      inputOnChange(syntheticEvent);
+    }
+  };
 
-  const handleKeyDown = (e: { key: string }) => {
-    if (inputOnChange && e.key === 'Enter') {
-      inputOnChange(e as any, {
-        value: keyword,
-      });
+  const handleKeyDown = (e: React.KeyboardEvent<HTMLInputElement>) => {
+    if (e.key === "Enter") {
+      handleSearch();
     }
   };
 
   return (
-    <Input
-      size="small"
-      placeholder="검색..."
-      style={{ margin: 0 }}
-      label={<${names.capital}SearchFieldDropdown {...dropdownProps} />}
-      labelPosition="left"
-      action={{
-        icon: 'search',
-        onClick: () => handleKeyDown({ key: 'Enter' }),
-      }}
-      {...inputProps}
-      value={keyword}
-      onChange={(e, { value }) => setKeyword(value)}
-      onKeyDown={handleKeyDown}
-    />
+    <div className="flex items-center gap-1">
+      <${names.capital}SearchFieldSelect {...dropdownProps} />
+      <div className="relative flex items-center">
+        <Input
+          type="text"
+          placeholder="검색..."
+          className="h-8 w-[200px] pr-8"
+          value={keyword}
+          onChange={(e) => setKeyword(e.target.value)}
+          onKeyDown={handleKeyDown}
+        />
+        <Button type="button" variant="ghost" onClick={handleSearch} icon={<SearchIcon />} />
+      </div>
+    </div>
   );
 }
       `.trim(),

package/src/template/zod-converter.ts

@@ -513,7 +513,10 @@ export function zodTypeToRenderingNode(
     };
   } else if (zodType instanceof z.ZodArray) {
     const innerType = (zodType as z.ZodArray<z.ZodTypeAny>).def.element;
-    if (innerType instanceof z.ZodString && baseKey.includes("images")) {
+    if (
+      innerType instanceof z.ZodString &&
+      (baseKey.includes("images") || baseKey.includes("image"))
+    ) {
       return {
         ...def,
         renderType: "array-images",

package/src/testing/bootstrap.ts

@@ -0,0 +1,176 @@
+import {
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  type TestFunction,
+  type TestOptions,
+  type VitestUtils,
+  test as vitestTest,
+} from "vitest";
+import type { AuthContext, Context } from "../api/context";
+import { Sonamu } from "../api/sonamu";
+import { DB } from "../database/db";
+import { Naite } from "../naite/naite";
+import { NaiteReporter } from "../naite/naite-reporter";
+
+export function bootstrap(vi: VitestUtils) {
+  beforeAll(async () => {
+    await Sonamu.initForTesting();
+  });
+  beforeEach(async () => {
+    await DB.createTestTransaction();
+  });
+  afterEach(async ({ task }) => {
+    vi.useRealTimers();
+    await DB.clearTestTransaction();
+
+    await NaiteReporter.reportTestResult({
+      suiteName: task.suite?.name ?? "(no suite)",
+      suiteFilePath: task.file?.filepath,
+      testName: task.name,
+      testFilePath: task.file?.filepath ?? "",
+      testLine: task.location?.line ?? 0,
+      status: task.result?.state ?? "pass",
+      duration: task.result?.duration ?? 0,
+      error: task.result?.errors?.[0]
+        ? {
+            message: task.result.errors[0].message,
+            stack: task.result.errors[0].stack,
+          }
+        : undefined,
+      traces: task.meta?.traces ?? [],
+    });
+  });
+  afterAll(() => {});
+}
+
+function getMockContext(): Context {
+  return {
+    ip: "127.0.0.1",
+    session: {},
+    user: null,
+    passport: {
+      login: async () => {},
+      logout: () => {},
+    },
+    naiteStore: Naite.createStore(),
+  } as unknown as Context;
+}
+
+export async function runWithContext(context: Context | null, fn: () => Promise<void>) {
+  // Sonamu.asyncLocalStorage.run으로 context 설정
+  await Sonamu.asyncLocalStorage.run({ context: context ?? getMockContext() }, fn);
+}
+
+export async function runWithMockContext(fn: () => Promise<void>) {
+  await runWithContext(getMockContext(), fn);
+}
+
+declare module "vitest" {
+  interface TaskMeta {
+    traces: {
+      key: string;
+      // biome-ignore lint/suspicious/noExplicitAny: expect와 호응하도록 any를 허용함.
+      value: any;
+      filePath: string;
+      lineNumber: number;
+      at: string;
+    }[];
+  }
+}
+
+export const test = Object.assign(
+  async (title: string, fn: TestFunction<object>, options?: TestOptions) => {
+    return vitestTest(title, options, async (context) => {
+      await runWithMockContext(async () => {
+        try {
+          await fn(context);
+          context.task.meta.traces = Naite.getAllTraces();
+        } catch (e: unknown) {
+          context.task.meta.traces = Naite.getAllTraces();
+          throw e;
+        }
+      });
+    });
+  },
+  {
+    skip: async (title: string, fn: TestFunction<object>, options?: TestOptions) =>
+      vitestTest.skip(title, options, fn),
+    only: async (title: string, fn: TestFunction<object>, options?: TestOptions) => {
+      return vitestTest.only(title, options, async (context) => {
+        await runWithMockContext(async () => {
+          try {
+            await fn(context);
+            context.task.meta.traces = Naite.getAllTraces();
+          } catch (e: unknown) {
+            context.task.meta.traces = Naite.getAllTraces();
+            throw e;
+          }
+        });
+      });
+    },
+    todo: (title: string) => vitestTest.todo(title),
+    each: vitestTest.each.bind(vitestTest) as typeof vitestTest.each,
+  },
+);
+
+export const testAs = Object.assign(
+  async <User extends AuthContext["user"]>(
+    user: User,
+    title: string,
+    fn: TestFunction<object>,
+    options?: TestOptions,
+  ) => {
+    return vitestTest(title, options, async (context) => {
+      await runWithContext(
+        {
+          ...getMockContext(),
+          user,
+        },
+        async () => {
+          try {
+            await fn(context);
+            context.task.meta.traces = Naite.getAllTraces();
+          } catch (e: unknown) {
+            context.task.meta.traces = Naite.getAllTraces();
+            throw e;
+          }
+        },
+      );
+    });
+  },
+  {
+    skip: async <User extends AuthContext["user"]>(
+      _user: User,
+      title: string,
+      fn: TestFunction<object>,
+      options?: TestOptions,
+    ) => vitestTest.skip(title, options, fn),
+    only: async <User extends AuthContext["user"]>(
+      user: User,
+      title: string,
+      fn: TestFunction<object>,
+      options?: TestOptions,
+    ) => {
+      return vitestTest.only(title, options, async (context) => {
+        await runWithContext(
+          {
+            ...getMockContext(),
+            user,
+          },
+          async () => {
+            try {
+              await fn(context);
+              context.task.meta.traces = Naite.getAllTraces();
+            } catch (e: unknown) {
+              context.task.meta.traces = Naite.getAllTraces();
+              throw e;
+            }
+          },
+        );
+      });
+    },
+    todo: (title: string) => vitestTest.todo(title),
+  },
+);

package/src/testing/fixture-loader.ts

@@ -0,0 +1,28 @@
+/**
+ * Fixture Loader Factory
+ *
+ * 테스트에서 사용할 fixture를 로드하는 함수를 생성
+ *
+ * @example
+ * ```typescript
+ * // fixture.ts
+ * import { createFixtureLoader } from "sonamu/test";
+ *
+ * export const loadFixtures = createFixtureLoader({
+ *   company01: async () => CompanyModel.findById("A", 1),
+ *   user01: async () => UserModel.findById("A", 1),
+ * });
+ *
+ * // test.ts
+ * const { company01, user01 } = await loadFixtures(["company01", "user01"]);
+ * ```
+ */
+export function createFixtureLoader<T extends Record<string, () => Promise<unknown>>>(loaders: T) {
+  return async function loadFixtures<K extends keyof T>(
+    names: K[],
+  ): Promise<{ [P in K]: Awaited<ReturnType<T[P]>> }> {
+    return Object.fromEntries(
+      await Promise.all(names.map(async (name) => [name, await loaders[name]()])),
+    );
+  };
+}

package/src/testing/fixture-manager.ts

@@ -3,12 +3,13 @@ import chalk from "chalk";
 import { execSync } from "child_process";
 import { readFileSync, writeFileSync } from "fs";
 import inflection from "inflection";
-import knex, { type Knex } from "knex";
+import type { Knex } from "knex";
 import { unique } from "radashi";
 import { inspect } from "util";
 import { Sonamu } from "../api";
 import { BaseModel } from "../database/base-model";
 import type { SonamuDBConfig } from "../database/db";
+import { createKnexInstance } from "../database/knex";
 import { type UBRef, UpsertBuilder } from "../database/upsert-builder";
 import type { Entity } from "../entity/entity";
 import { EntityManager } from "../entity/entity-manager";
@@ -86,8 +87,8 @@ export class FixtureManagerClass {
       }
     }
 
-    this.tdb = knex(Sonamu.dbConfig.test);
-    this.fdb = knex(Sonamu.dbConfig.fixture);
+    this.tdb = createKnexInstance(Sonamu.dbConfig.test);
+    this.fdb = createKnexInstance(Sonamu.dbConfig.fixture);
   }
 
   async getChecksum(db: Knex, tableName: string) {
@@ -254,8 +255,8 @@ export class FixtureManagerClass {
     searchOptions: FixtureSearchOptions,
     duplicateCheck?: DuplicateCheckOptions,
   ) {
-    const sourceDB = knex(Sonamu.dbConfig[sourceDBName]);
-    const targetDB = knex(Sonamu.dbConfig[targetDBName]);
+    const sourceDB = createKnexInstance(Sonamu.dbConfig[sourceDBName]);
+    const targetDB = createKnexInstance(Sonamu.dbConfig[targetDBName]);
 
     const { entityId, field, value, searchType } = searchOptions;
 
@@ -442,7 +443,7 @@ export class FixtureManagerClass {
     this.uuidToFixtureId = new Map();
     this.skippedFixtures = new Map();
 
-    const db = knex(Sonamu.dbConfig[dbName]);
+    const db = createKnexInstance(Sonamu.dbConfig[dbName]);
     const results: FixtureImportResult[] = [];
 
     try {

package/src/testing/index.ts

@@ -0,0 +1,3 @@
+export * from "./bootstrap";
+export * from "./fixture-loader";
+export * from "./naite-vitest-reporter";

package/src/testing/naite-vitest-reporter.ts

@@ -0,0 +1,18 @@
+import { NaiteReporter } from "../naite/naite-reporter";
+
+/**
+ * Naite Vitest Reporter
+ *
+ * 테스트 런 시작/종료를 정확히 감지하여 NaiteReporter에 알립니다.
+ * - onTestRunStart: 테스트 런 시작 시 (첫 실행 및 watch 재실행 포함)
+ * - onTestRunEnd: 각 런 종료 시
+ */
+export const NaiteVitestReporter = {
+  async onTestRunStart() {
+    await NaiteReporter.startTestRun();
+  },
+
+  async onTestRunEnd() {
+    await NaiteReporter.endTestRun();
+  },
+};

package/src/types/types.ts

@@ -1268,14 +1268,12 @@ export const TemplateOptions = z.object({
     entityId: z.string(),
     enumId: z.string(),
   }),
-  view_enums_dropdown: z.object({
-    entityId: z.string(),
-    enumId: z.string(),
-  }),
   view_enums_buttonset: z.object({
     entityId: z.string(),
     enumId: z.string(),
   }),
+  queries: z.object({}),
+  entry_server: z.object({}),
 });
 export type TemplateOptions = z.infer<typeof TemplateOptions>;
 
@@ -1296,8 +1294,9 @@ export const TemplateKey = z.enum([
   "view_id_all_select",
   "view_id_async_select",
   "view_enums_select",
-  "view_enums_dropdown",
   "view_enums_buttonset",
+  "queries",
+  "entry_server",
 ]);
 export type TemplateKey = z.infer<typeof TemplateKey>;
 

package/src/ui/ai-client.ts

@@ -1,13 +1,5 @@
 /** biome-ignore-all lint/suspicious/noExplicitAny: AI SDK의 타입이 명확하지 않아 any를 허용함 */
-import { anthropic } from "@ai-sdk/anthropic";
-import {
-  type LanguageModel,
-  type ModelMessage,
-  type StreamTextResult,
-  stepCountIs,
-  streamText,
-  tool,
-} from "ai";
+import type { LanguageModel, ModelMessage, StreamTextResult } from "ai";
 import assert from "assert";
 import fs from "fs";
 import path from "path";
@@ -29,16 +21,35 @@ type ValidationError = {
 };
 
 class AIClient {
-  private model = anthropic("claude-sonnet-4-5");
+  private model: LanguageModel | null = null;
+  private aiSdk:
+    | (typeof import("ai") & {
+        anthropic?: typeof import("@ai-sdk/anthropic").anthropic;
+      })
+    | null = null;
 
   async init() {
-    console.log("AI client initialized with AI SDK");
+    try {
+      const { anthropic } = await import("@ai-sdk/anthropic");
+      const aiModule = await import("ai");
+      this.aiSdk = { ...aiModule, anthropic };
+      this.model = anthropic("claude-sonnet-4-5");
+    } catch (error) {
+      console.warn(
+        "AI SDK packages not installed. Install @ai-sdk/anthropic and ai to use AI features.",
+      );
+      throw error;
+    }
   }
 
   handleFixture(
     messages: ModelMessage[],
     fixtureRecords: FixtureRecord[],
   ): StreamTextResult<any, any> {
+    if (!this.aiSdk || !this.model) {
+      throw new Error("AI SDK not initialized. Call init() first.");
+    }
+
     // 현재 fixtureRecords에서 사용된 엔티티들의 구조 정보 수집
     const usedEntityIds = [...new Set(fixtureRecords.map((r) => r.entityId))];
     const entityStructures = usedEntityIds.map((entityId) => {
@@ -82,6 +93,8 @@ class AIClient {
         createFixtures({ fixtures: [{ entityId: "User", id: -1, columns: { name: "홍길동", email: "hong@example.com" } }] })
       `;
 
+    const { streamText, tool } = this.aiSdk;
+
     return streamText({
       model: this.model,
       system: systemMessage,
@@ -102,10 +115,14 @@ class AIClient {
           }),
           execute: async ({
             updates,
+          }: {
+            updates: Array<{ fixtureId: string; updates: Record<string, unknown> }>;
           }): Promise<{ success: boolean; updatedRecords: FixtureRecord[] }> => {
             // fixtureRecords를 복사하고 업데이트 적용
             const updatedRecords: FixtureRecord[] = fixtureRecords.map((record) => {
-              const update = updates.find((u) => u.fixtureId === record.fixtureId);
+              const update = updates.find(
+                (u: { fixtureId: string }) => u.fixtureId === record.fixtureId,
+              );
               if (update) {
                 // columns의 value를 업데이트
                 for (const [columnName, newValue] of Object.entries(update.updates)) {
@@ -137,44 +154,48 @@ class AIClient {
           }),
           execute: async ({
             fixtures,
+          }: {
+            fixtures: Array<{ entityId: string; id: number; columns: Record<string, unknown> }>;
           }): Promise<{ success: boolean; updatedRecords: FixtureRecord[] }> => {
-            const newRecords: FixtureRecord[] = fixtures.map((fixture) => {
-              const entity = EntityManager.get(fixture.entityId);
-
-              // 엔티티 props를 기반으로 columns 구성
-              const columns: FixtureRecord["columns"] = {};
-              for (const prop of entity.props) {
-                if (prop.type === "virtual") continue;
-
-                let value = fixture.columns[prop.name] ?? null;
-
-                if (prop.name === "created_at") {
-                  // 현재 시간으로 설정
-                  value = new Date().toISOString();
-                } else if (
-                  prop.type === "relation" &&
-                  (prop.relationType === "HasMany" || prop.relationType === "ManyToMany")
-                ) {
-                  // 배열로 변환
-                  value = Array.isArray(value) ? value : [value].filter(nonNullable);
+            const newRecords: FixtureRecord[] = fixtures.map(
+              (fixture: { entityId: string; id: number; columns: Record<string, unknown> }) => {
+                const entity = EntityManager.get(fixture.entityId);
+
+                // 엔티티 props를 기반으로 columns 구성
+                const columns: FixtureRecord["columns"] = {};
+                for (const prop of entity.props) {
+                  if (prop.type === "virtual") continue;
+
+                  let value = fixture.columns[prop.name] ?? null;
+
+                  if (prop.name === "created_at") {
+                    // 현재 시간으로 설정
+                    value = new Date().toISOString();
+                  } else if (
+                    prop.type === "relation" &&
+                    (prop.relationType === "HasMany" || prop.relationType === "ManyToMany")
+                  ) {
+                    // 배열로 변환
+                    value = Array.isArray(value) ? value : [value].filter(nonNullable);
+                  }
+
+                  columns[prop.name] = {
+                    prop,
+                    value: value as FixtureRecord["columns"][string]["value"],
+                  };
                 }
 
-                columns[prop.name] = {
-                  prop,
-                  value: value as FixtureRecord["columns"][string]["value"],
+                return {
+                  fixtureId: `${fixture.entityId}#${fixture.id}`,
+                  entityId: fixture.entityId,
+                  id: fixture.id,
+                  columns,
+                  fetchedRecords: [],
+                  belongsRecords: [],
+                  override: false,
                 };
-              }
-
-              return {
-                fixtureId: `${fixture.entityId}#${fixture.id}`,
-                entityId: fixture.entityId,
-                id: fixture.id,
-                columns,
-                fetchedRecords: [],
-                belongsRecords: [],
-                override: false,
-              };
-            });
+              },
+            );
 
             // 새 레코드들의 relation 컬럼을 확인하여 기존 레코드들의 역방향 relation 업데이트
             for (const newRecord of newRecords) {
@@ -232,6 +253,10 @@ class AIClient {
   }
 
   handleEntity(messages: ModelMessage[]): StreamTextResult<any, any> {
+    if (!this.aiSdk || !this.model) {
+      throw new Error("AI SDK not initialized. Call init() first.");
+    }
+
     // entity.instructions.md 파일 읽기 (dist/ui 또는 src/ui에서 실행되므로 패키지 루트 기준으로 접근)
     const instructionsPath = path.join(
       import.meta.dirname,
@@ -326,6 +351,8 @@ updateEntity({ entityId: "Project", updates: { props: [{ name: "priority", type:
 | "onUpdate가 필수" | 해당 relation prop에 onUpdate, onDelete 추가 ("CASCADE") |
       `;
 
+    const { streamText, tool, stepCountIs } = this.aiSdk;
+
     return streamText({
       model: this.model as unknown as LanguageModel,
       system: systemMessage,
@@ -337,7 +364,7 @@ updateEntity({ entityId: "Project", updates: { props: [{ name: "priority", type:
             "새로운 Entity를 생성합니다. 사용자가 새로운 엔티티나 테이블 생성을 요청할 때 사용하세요.",
           inputSchema: TemplateOptions.shape.entity,
           execute: async (
-            entity,
+            entity: z.infer<typeof TemplateOptions.shape.entity>,
           ): Promise<{
             success: boolean;
             entityId: string;
@@ -388,6 +415,10 @@ updateEntity({ entityId: "Project", updates: { props: [{ name: "priority", type:
             entityId,
             updates,
             mode = "merge",
+          }: {
+            entityId: string;
+            updates: Partial<z.infer<typeof TemplateOptions.shape.entity>>;
+            mode?: "merge" | "replace";
           }): Promise<{
             success: boolean;
             entityId: string;
@@ -432,10 +463,11 @@ updateEntity({ entityId: "Project", updates: { props: [{ name: "priority", type:
                 const normalizedSubsetsInternal: { [key: string]: string[] } = {};
 
                 for (const [key, fields] of Object.entries(updates.subsets)) {
-                  normalizedSubsets[key] = fields
-                    .filter((f) => !isInternalSubsetField(f))
+                  const fieldArray = fields as string[];
+                  normalizedSubsets[key] = fieldArray
+                    .filter((f: string) => !isInternalSubsetField(f))
                     .map(normalizeSubsetField);
-                  normalizedSubsetsInternal[key] = fields
+                  normalizedSubsetsInternal[key] = fieldArray
                     .filter(isInternalSubsetField)
                     .map(normalizeSubsetField);
                 }

package/dist/template/implementations/view_enums_dropdown.template.d.ts

@@ -1,17 +0,0 @@
-import { type EntityNamesRecord } from "../../entity/entity-manager";
-import type { TemplateOptions } from "../../types/types";
-import { Template } from "../template";
-export declare class Template__view_enums_dropdown extends Template {
-    constructor();
-    getTargetAndPath(names: EntityNamesRecord, enumId: string): {
-        target: string;
-        path: string;
-    };
-    render({ entityId, enumId }: TemplateOptions["view_enums_dropdown"]): {
-        body: string;
-        importKeys: never[];
-        target: string;
-        path: string;
-    };
-}
-//# sourceMappingURL=view_enums_dropdown.template.d.ts.map

package/dist/template/implementations/view_enums_dropdown.template.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"view_enums_dropdown.template.d.ts","sourceRoot":"","sources":["../../../src/template/implementations/view_enums_dropdown.template.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AACpF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEzD,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC,qBAAa,6BAA8B,SAAQ,QAAQ;;IAKzD,gBAAgB,CAAC,KAAK,EAAE,iBAAiB,EAAE,MAAM,EAAE,MAAM;;;;IAOzD,MAAM,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,eAAe,CAAC,qBAAqB,CAAC;;;;;;CAmCpE"}