sonamu 0.7.4 → 0.7.6

package/src/migration/migration-set.ts

@@ -11,6 +11,7 @@ import {
   isOneToOneRelationProp,
   isRelationProp,
   isStringProp,
+  isVectorProp,
   isVirtualProp,
   type MigrationColumn,
   type MigrationColumnType,
@@ -63,6 +64,14 @@ export function getMigrationSetFromEntity(entity: Entity): MigrationSetAndJoinTa
             scale: prop.scale,
             numberType: isNumberProp(prop) ? (prop.numberType ?? "numeric") : "numeric",
           }),
+          // Vector 타입의 경우 dimensions 추가
+          ...(isVectorProp(prop) && {
+            dimensions: prop.dimensions,
+          }),
+          // Generated Column 정보 추가
+          ...(prop.generated && {
+            generated: prop.generated,
+          }),
         };
 
         r.columns.push(column);
@@ -90,10 +99,16 @@ export function getMigrationSetFromEntity(entity: Entity): MigrationSetAndJoinTa
           indexes: [
             // 조인 테이블에 걸린 인덱스 찾아와서 연결
             ...entity.indexes
-              .filter((index) => index.columns.find((col) => col.includes(`${prop.joinTable}.`)))
+              .filter((index) =>
+                index.columns.find((col) => col.name.includes(`${prop.joinTable}.`)),
+              )
               .map((index) => ({
                 ...index,
-                columns: index.columns.map((col) => col.replace(`${prop.joinTable}.`, "")),
+                columns: index.columns.map((col) => ({
+                  name: col.name.replace(`${prop.joinTable}.`, ""),
+                  nullsFirst: col.nullsFirst,
+                  sortOrder: col.sortOrder,
+                })),
               })),
           ],
           columns: [
@@ -163,7 +178,7 @@ export function getMigrationSetFromEntity(entity: Entity): MigrationSetAndJoinTa
 
   // indexes
   migrationSet.indexes = entity.indexes.filter((index) =>
-    index.columns.find((col) => col.includes(".") === false),
+    index.columns.find((col) => col.name.includes(".") === false),
   );
 
   return migrationSet;
@@ -213,6 +228,10 @@ function resolveEntityPropTypeToMigrationColumnType(prop: EntityProp): Migration
       return "uuid[]";
     case "json":
       return "json";
+    case "vector":
+      return "vector";
+    case "vector[]":
+      return "vector[]";
     default:
       exhaustive(prop);
       throw new Error(`Unknown entity prop type: ${(prop as { type: string }).type}`);

package/src/migration/migrator.ts

@@ -405,6 +405,12 @@ export class Migrator {
     const tdb = knex(Sonamu.dbConfig.test);
     !isTest() && console.log(chalk.magenta(`${shadowDatabase} 삭제`));
     await tdb.raw(`DROP DATABASE IF EXISTS ${shadowDatabase}`);
+    await tdb.raw(`
+      SELECT pg_terminate_backend(pg_stat_activity.pid)
+      FROM pg_stat_activity
+      WHERE datname = '${tdbConn.database}'
+        AND pid <> pg_backend_pid();
+    `);
     await tdb.raw(`CREATE DATABASE ${shadowDatabase} TEMPLATE ${tdbConn.database}`);
 
     // Shadow DB에 연결

package/src/migration/postgresql-schema-reader.ts

@@ -18,6 +18,8 @@ export type PgColumn = {
   numeric_scale: number | null;
   is_nullable: string;
   column_default: string | null;
+  is_generated: string; // 's' = STORED, 'v' = VIRTUAL, '' = none
+  generation_expression: string | null;
 };
 
 type PgIndex = {
@@ -26,6 +28,9 @@ type PgIndex = {
   is_unique: boolean;
   is_primary: boolean;
   index_type: string;
+  nulls_first: boolean;
+  sort_order: "ASC" | "DESC";
+  nulls_not_distinct: boolean;
 };
 
 type PgForeign = {
@@ -56,13 +61,40 @@ class PostgreSQLSchemaReaderClass {
       return null;
     }
 
+    // vector 컬럼의 dimensions 조회
+    const vectorDimensions = await this.getVectorDimensions(compareDB, table);
+
     const columns: MigrationColumn[] = dbColumns.map((dbColumn) => {
       const dbColType = this.resolveDBColType(dbColumn);
+
+      // vector 타입인 경우 dimensions 설정
+      if (dbColType.type === "vector") {
+        dbColType.dimensions = vectorDimensions[dbColumn.column_name] ?? 0;
+      }
+
       return {
         name: dbColumn.column_name,
         nullable: dbColumn.is_nullable === "YES",
         ...dbColType,
+        // Generated Column 처리
+        ...(() => {
+          if (dbColumn.is_generated === "s" || dbColumn.is_generated === "v") {
+            return {
+              generated: {
+                type: dbColumn.is_generated === "s" ? "STORED" : "VIRTUAL",
+                expression: dbColumn.generation_expression ?? "",
+              },
+            };
+          }
+          return {};
+        })(),
+        // Default 값 처리 (Generated Column이 아닌 경우만)
         ...(() => {
+          // Generated Column은 default 값이 없음
+          if (dbColumn.is_generated === "s" || dbColumn.is_generated === "v") {
+            return {};
+          }
+
           if (dbColumn.column_default !== null) {
             // PostgreSQL default 값 정리 (nextval, CURRENT_TIMESTAMP 등)
             let defaultValue = dbColumn.column_default;
@@ -75,9 +107,9 @@ class PostgreSQLSchemaReaderClass {
             // 타입 캐스팅 제거 (예: '1'::integer → 1)
             defaultValue = defaultValue.replace(/::[\w\s]+$/g, "");
 
-            // 따옴표 제거가 필요한 경우
+            // 따옴표가 single quote인 경우 double quote로 변환
             if (defaultValue.startsWith("'") && defaultValue.endsWith("'")) {
-              defaultValue = defaultValue.slice(1, -1);
+              defaultValue = defaultValue.replaceAll("'", '"');
             }
 
             return {
@@ -110,7 +142,12 @@ class PostgreSQLSchemaReaderClass {
       return {
         type,
         name: indexName,
-        columns: currentIndexes.map((idx) => idx.column_name),
+        columns: currentIndexes.map((idx) => ({
+          name: idx.column_name,
+          nullsFirst: idx.nulls_first,
+          sortOrder: idx.sort_order,
+        })),
+        nullsNotDistinct: firstIndex.nulls_not_distinct,
       };
     });
 
@@ -153,21 +190,30 @@ class PostgreSQLSchemaReaderClass {
     compareDB: Knex,
     tableName: string,
   ): Promise<[PgColumn[], PgIndex[], PgForeign[]]> {
-    // Columns 조회
-    const columns = await compareDB
-      .select(
-        "column_name",
-        "data_type",
-        "udt_name",
-        "character_maximum_length",
-        "numeric_precision",
-        "numeric_scale",
-        "is_nullable",
-        "column_default",
-      )
-      .from("information_schema.columns")
-      .where({ table_name: tableName })
-      .orderBy("ordinal_position");
+    // Columns 조회 (Generated Column 정보 포함)
+    const columnsQuery = `
+      SELECT
+        c.column_name,
+        c.data_type,
+        c.udt_name,
+        c.character_maximum_length,
+        c.numeric_precision,
+        c.numeric_scale,
+        c.is_nullable,
+        c.column_default,
+        COALESCE(a.attgenerated, '') as is_generated,
+        c.generation_expression
+      FROM information_schema.columns c
+      LEFT JOIN pg_attribute a ON a.attname = c.column_name
+        AND a.attrelid = (
+          SELECT oid FROM pg_class WHERE relname = c.table_name
+          AND relnamespace = (SELECT oid FROM pg_namespace WHERE nspname = c.table_schema)
+        )
+      WHERE c.table_name = ?
+        AND c.table_schema = 'public'
+      ORDER BY c.ordinal_position
+    `;
+    const columns = (await compareDB.raw(columnsQuery, [tableName])).rows as PgColumn[];
     if (columns.length === 0) {
       throw new Error(`Table not found: ${tableName}`);
     }
@@ -179,12 +225,23 @@ class PostgreSQLSchemaReaderClass {
         a.attname as column_name,
         ix.indisunique as is_unique,
         ix.indisprimary as is_primary,
-        am.amname as index_type
+        am.amname as index_type,
+        -- NULLS FIRST/LAST 확인 (비트 연산)
+        (opt & 2) = 2 AS nulls_first,
+        -- ASC/DESC 확인
+        CASE 
+            WHEN (opt & 1) = 1 THEN 'DESC'
+            ELSE 'ASC'
+        END AS sort_order,
+        ix.indnullsnotdistinct AS nulls_not_distinct
       FROM pg_class t
       JOIN pg_index ix ON t.oid = ix.indrelid
       JOIN pg_class i ON i.oid = ix.indexrelid
-      JOIN pg_attribute a ON a.attrelid = t.oid
       JOIN pg_am am ON i.relam = am.oid
+        JOIN LATERAL unnest(ix.indkey, ix.indoption)
+            WITH ORDINALITY AS u(attnum, opt, ord) ON true
+        -- unnest에서 나온 attnum으로 직접 조인
+      JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = u.attnum
       WHERE t.relname = ?
         AND a.attnum = ANY(ix.indkey)
       ORDER BY i.relname, array_position(ix.indkey, a.attnum)
@@ -218,12 +275,43 @@ class PostgreSQLSchemaReaderClass {
     return [columns, indexes, foreigns];
   }
 
+  /**
+   * vector 컬럼의 dimensions를 조회합니다.
+   * pg_attribute의 atttypmod에서 차원 수를 추출합니다.
+   */
+  private async getVectorDimensions(
+    compareDB: Knex,
+    tableName: string,
+  ): Promise<Record<string, number>> {
+    const query = `
+      SELECT
+        a.attname as column_name,
+        a.atttypmod as dimensions
+      FROM pg_attribute a
+      JOIN pg_class c ON a.attrelid = c.oid
+      JOIN pg_type t ON a.atttypid = t.oid
+      WHERE c.relname = ?
+        AND t.typname = 'vector'
+        AND a.attnum > 0
+    `;
+    const result = await compareDB.raw(query, [tableName]);
+    const dimensions: Record<string, number> = {};
+    for (const row of result.rows) {
+      // atttypmod에서 실제 dimensions 값 추출
+      dimensions[row.column_name] = row.dimensions > 0 ? row.dimensions : 0;
+    }
+    return dimensions;
+  }
+
   /**
    * PostgreSQL 컬럼 타입을 분석하여 MigrationColumn 객체로 변환합니다.
    */
   resolveDBColType(
     dbColumn: PgColumn,
-  ): Pick<MigrationColumn, "type" | "length" | "precision" | "scale" | "numberType"> {
+  ): Pick<
+    MigrationColumn,
+    "type" | "length" | "precision" | "scale" | "numberType" | "dimensions"
+  > {
     const {
       udt_name: _udt_name,
       character_maximum_length,
@@ -304,6 +392,18 @@ class PostgreSQLSchemaReaderClass {
       return { type: "json" };
     }
 
+    // Vector (pgvector)
+    if (udt_name === "vector") {
+      // vector 타입의 차원 수는 column_default나 별도 쿼리로 확인해야 함
+      // 현재는 기본값 0으로 설정 (실제 dimensions는 getMigrationSetFromDB에서 별도 쿼리로 확인)
+      return { type: `vector${singleOrArray}`, dimensions: 0 };
+    }
+
+    // tsvector (PostgreSQL 전문 검색용 타입)
+    if (udt_name === "tsvector") {
+      return { type: "tsvector" };
+    }
+
     throw new Error(`resolve 불가능한 PostgreSQL 컬럼 타입: ${udt_name}`);
   }
 }

package/src/syncer/syncer.ts

@@ -2,6 +2,7 @@ import { hot } from "@sonamu-kit/hmr-hook";
 import assert from "assert";
 import chalk from "chalk";
 import { mkdir, readFile, writeFile } from "fs/promises";
+import inflection from "inflection";
 import { minimatch } from "minimatch";
 import path, { dirname } from "path";
 import { group, unique } from "radashi";
@@ -321,11 +322,13 @@ export class Syncer {
           namesRecord: EntityManager.getNamesFromId(entityId),
         };
       }
-      if (modelPath.endsWith("frame.ts")) {
-        const [, frameName] = modelPath.match(/.+\/(.+)\.frame.js$/) ?? [];
+      if (modelPath.endsWith(".frame.ts")) {
+        const [, frameName] = modelPath.match(/.+\/(.+)\.frame\.ts$/) ?? [];
         assert(frameName);
+        // frameName을 PascalCase로 변환 (dashboard -> Dashboard)
+        const frameId = inflection.camelize(frameName);
         return {
-          namesRecord: EntityManager.getNamesFromId(frameName),
+          namesRecord: EntityManager.getNamesFromId(frameId),
         };
       }
       throw new Error("not reachable");

package/src/template/implementations/generated.template.ts

@@ -177,18 +177,60 @@ export class Template__generated extends Template {
       .filter((prop) => isVirtualProp(prop))
       .map((prop) => prop.name);
 
+    /**
+     * hasDefault props
+     * - nullable 또는 dbDefault가 있는 컬럼 (id 포함)
+     * - relation이 아니거나, relation이어도 nullable이면 포함
+     */
+    const hasDefaultColumns = entity.props
+      .filter(
+        (prop) =>
+          (prop.type !== "relation" || prop.nullable === true) &&
+          (prop.nullable === true || (prop.type !== "relation" && prop.dbDefault !== undefined)),
+      )
+      .map((prop) => (prop.type === "relation" ? `${prop.name}_id` : prop.name))
+      .concat("id");
+
+    /**
+     * generated props
+     * - generated 속성이 있는 컬럼 (INSERT/UPDATE 시 값 제공 불가)
+     */
+    const generatedColumns = entity.props
+      .filter((prop) => prop.type !== "relation" && prop.generated !== undefined)
+      .map((prop) => prop.name);
+
+    const hasMetadata =
+      fulltextColumns.length > 0 ||
+      virtualProps.length > 0 ||
+      hasDefaultColumns.length > 0 ||
+      generatedColumns.length > 0;
+
     const lines = [
       `export const ${schemaName} = ${schemaBody};`,
       `export type ${schemaName} = z.infer<typeof ${schemaName}>` +
-        (fulltextColumns.length > 0
-          ? ` & { readonly __fulltext__: readonly [${fulltextColumns
-              .map((col) => `"${col}"`)
-              .join(", ")}] }`
-          : "") +
-        (virtualProps.length > 0
-          ? ` & { readonly __virtual__: readonly [${virtualProps
-              .map((prop) => `"${prop}"`)
-              .join(", ")}] }`
+        (hasMetadata
+          ? ` & {${
+              (fulltextColumns.length > 0
+                ? `readonly __fulltext__: readonly [${fulltextColumns
+                    .map((col) => `"${col}"`)
+                    .join(", ")}],`
+                : "") +
+              (virtualProps.length > 0
+                ? `readonly __virtual__: readonly [${virtualProps.map((prop) => `"${prop}"`).join(", ")}],`
+                : "") +
+              (
+                hasDefaultColumns.length > 0
+                  ? `readonly __hasDefault__: readonly [${hasDefaultColumns
+                      .map((col) => `"${col}"`)
+                      .join(", ")}],`
+                  : ""
+              ) +
+              (generatedColumns.length > 0
+                ? `readonly __generated__: readonly [${generatedColumns
+                    .map((col) => `"${col}"`)
+                    .join(", ")}],`
+                : "")
+            }}`
           : "") +
         ";",
     ];

package/src/template/implementations/generated_sso.template.ts

@@ -4,7 +4,11 @@ import { unique } from "radashi";
 import { Sonamu } from "../../api";
 import type { Entity } from "../../entity/entity";
 import { EntityManager } from "../../entity/entity-manager";
-import { isManyToManyRelationProp } from "../../types/types";
+import {
+  isBelongsToOneRelationProp,
+  isManyToManyRelationProp,
+  isOneToOneRelationProp,
+} from "../../types/types";
 import { Template } from "../template";
 import type { SourceCode } from "./generated.template";
 
@@ -71,6 +75,12 @@ export class Template__generated_sso extends Template {
       return [puriSubsetQuery, puriLoaderQuery];
     });
 
+    // ForeignKey 타입 생성
+    const fkTypeSourceCode = this.getForeignKeyTypeSourceCode(entities);
+    if (fkTypeSourceCode) {
+      sourceCodes.push(fkTypeSourceCode);
+    }
+
     // DatabaseSchema 생성
     const dbSchemaSourceCode = this.getDatabaseSchemaSourceCode(entities);
     if (dbSchemaSourceCode) {
@@ -114,11 +124,15 @@ export class Template__generated_sso extends Template {
     };
   }
 
-  getDatabaseSchemaSourceCode(entities: Entity[]): SourceCode | null {
+  //===============================================
+  // private Helper Methods
+  //===============================================
+  private getDatabaseSchemaSourceCode(entities: Entity[]): SourceCode | null {
     if (entities.length === 0) {
       return null;
     }
 
+    // DatabaseSchemaExtend - 테이블 스키마 타입 정의
     const entitySchemaLines = entities.map((entity) => `${entity.table}: ${entity.id}BaseSchema;`);
 
     const joinTables = unique(
@@ -132,6 +146,14 @@ export class Template__generated_sso extends Template {
       (joinTable) => joinTable.table,
     );
 
+    // DatabaseForeignKeys - FK 컬럼을 가진 테이블만 정의
+    const entitiesWithFk = entities.filter(
+      (entity) => this.getForeignKeyColumns(entity).length > 0,
+    );
+    const fkMetadataLines = entitiesWithFk.map(
+      (entity) => `${entity.table}: ${entity.id}ForeignKeys;`,
+    );
+
     return {
       label: `DatabaseSchema`,
       lines: [
@@ -143,9 +165,56 @@ export class Template__generated_sso extends Template {
             `${joinTable.table}: ManyToManyBaseSchema<"${joinTable.fromTableKey}", "${joinTable.toTableKey}">;`,
         ),
         `  }`,
+        ``,
+        `  export interface DatabaseForeignKeys {`,
+        ...fkMetadataLines,
+        `  }`,
         `}`,
       ],
       importKeys: entities.map((entity) => `${entity.id}BaseSchema`),
     };
   }
+
+  // FK 관계를 컬럼명으로 변환 (예: company → company_id)
+  private getForeignKeyColumns(entity: Entity): string[] {
+    return entity.props
+      .filter((prop) => {
+        if (isBelongsToOneRelationProp(prop)) {
+          return true;
+        }
+        if (isOneToOneRelationProp(prop) && prop.hasJoinColumn) {
+          return true;
+        }
+        return false;
+      })
+      .map((prop) => `${prop.name}_id`);
+  }
+
+  private getForeignKeyTypeSourceCode(entities: Entity[]): SourceCode | null {
+    if (entities.length === 0) {
+      return null;
+    }
+
+    // FK가 있는 엔티티만 타입 생성
+    const entitiesWithFk = entities.filter(
+      (entity) => this.getForeignKeyColumns(entity).length > 0,
+    );
+
+    if (entitiesWithFk.length === 0) {
+      return null;
+    }
+
+    const fkTypeLines = entitiesWithFk.map((entity) => {
+      const fkColumns = this.getForeignKeyColumns(entity);
+      const fkTypeValue = fkColumns.map((col) => `"${col}"`).join(" | ");
+
+      return `export type ${entity.id}ForeignKeys = ${fkTypeValue};`;
+    });
+
+    return {
+      label: `ForeignKey Types`,
+      lines: fkTypeLines,
+      importKeys: [],
+    };
+  }
 }

package/src/template/implementations/model.template.ts

@@ -1,3 +1,4 @@
+import type z from "zod";
 import { Sonamu } from "../../api";
 import { EntityManager, type EntityNamesRecord } from "../../entity/entity-manager";
 import { Naite } from "../../naite/naite";
@@ -5,7 +6,6 @@ import type { TemplateOptions } from "../../types/types";
 import { Template } from "../template";
 import { getZodTypeById, zodTypeToRenderingNode } from "../zod-converter";
 import { Template__view_list } from "./view_list.template";
-
 export class Template__model extends Template {
   constructor() {
     super("model");
@@ -26,6 +26,9 @@ export class Template__model extends Template {
     const listParamsZodType = await getZodTypeById(`${entityId}ListParams`);
     const listParamsNode = zodTypeToRenderingNode(listParamsZodType);
 
+    const subsetKeyZodType = await getZodTypeById(`${entityId}SubsetKey`);
+    const subsetKeys = (subsetKeyZodType as z.ZodEnum).enum;
+
     const names = EntityManager.getNamesFromId(entityId);
     const entity = EntityManager.get(entityId);
 
@@ -91,17 +94,17 @@ class ${entityId}ModelClass extends BaseModelClass<
   }
 
   @api({ httpMethod: "GET", clients: ["axios", "swr"], resourceName: "${names.capitalPlural}" })
-  async findMany<T extends ${entityId}SubsetKey>(
+  async findMany<T extends ${entityId}SubsetKey, LP extends ${entityId}ListParams>(
     subset: T,
-    params: ${entityId}ListParams = {}
-  ): Promise<ListResult<${entityId}SubsetMapping[T]>> {
+    rawParams?: LP,
+  ): Promise<ListResult<LP, ${entityId}SubsetMapping[T]>> {
     // params with defaults
-    params = {
+    const params = {
       num: 24,
       page: 1,
-      search: "${def.search}",
-      orderBy: "${def.orderBy}",
-      ...params,
+      search: "${def.search}" as const,
+      orderBy: "${def.orderBy}" as const,
+      ...rawParams,
     };
 
     // build queries
@@ -132,18 +135,25 @@ class ${entityId}ModelClass extends BaseModelClass<
         exhaustive(params.orderBy);
       }
     }
-    
-    const { rows, total } = await this.executeSubsetQuery({
+
+    const enhancers = this.createEnhancers({
+      ${Object.keys(subsetKeys)
+        .map(
+          (key) => `${key}: (row) => ({
+          ...row,
+          // 서브셋별로 virtual 필드 계산로직 추가
+        }),`,
+        )
+        .join("\n")}
+    });
+
+    return this.executeSubsetQuery({
       subset,
       qb,
       params,
+      enhancers,
       debug: false,
     });
-
-    return {
-      rows,
-      total,
-    };
   }
 
   @api({ httpMethod: "POST" })

package/src/template/implementations/model_test.template.ts

@@ -23,10 +23,10 @@ export class Template__model_test extends Template {
     return {
       ...this.getTargetAndPath(names),
       body: `
-import { describe, test, expect } from "vitest";
-import { bootstrap } from '../../testing/bootstrap';
+import { describe, expect, vi } from "vitest";
+import { bootstrap, test } from '../../testing/bootstrap';
 
-bootstrap();
+bootstrap(vi);
 describe.skip("${entityId}ModelTest", () => {
   test("Query", async () => {
     expect(true).toBe(true);

package/src/template/implementations/service.template.ts

@@ -36,7 +36,11 @@ export class Template__service extends Template {
       syncer: { apis },
     } = Sonamu;
 
-    const apisForThisModel = apis.filter((api) => api.modelName === `${namesRecord.capital}Model`);
+    const apisForThisModel = apis.filter(
+      (api) =>
+        api.modelName === `${namesRecord.capital}Model` ||
+        api.modelName === `${namesRecord.capital}Frame`,
+    );
 
     // 서비스 TypeSource
     const { lines, importKeys } = this.getTypeSource(apisForThisModel);

package/src/template/implementations/view_enums_dropdown.template.ts

@@ -28,7 +28,7 @@ import {
   DropdownProps,
 } from 'semantic-ui-react';
 
-import { ${enumId}Label } from 'src/services/sonamu.generated';
+import { ${enumId}Label } from '@/services/sonamu.generated';
 
 export function ${enumId}Dropdown(props: DropdownProps) {
   const options = Object.entries(${enumId}Label).map(([key, label]) => {

package/src/template/implementations/view_enums_select.template.ts

@@ -28,7 +28,7 @@ import {
   DropdownProps,
 } from 'semantic-ui-react';
 
-import { ${enumId}, ${enumId}Label } from 'src/services/sonamu.generated';
+import { ${enumId}, ${enumId}Label } from '@/services/sonamu.generated';
 
 export type ${enumId}SelectProps = {
   placeholder?: string;