sonamu 0.7.14 → 0.7.16

package/src/entity/entity.ts

@@ -14,12 +14,15 @@ import {
   isBelongsToOneRelationProp,
   isEnumProp,
   isHasManyRelationProp,
+  isInternalSubsetField,
   isManyToManyRelationProp,
   isOneToOneRelationProp,
   isRelationProp,
+  isVirtualCodeProp,
   isVirtualProp,
+  normalizeSubsetField,
   type RelationProp,
-  type StringProp,
+  type SubsetField,
   type SubsetQuery,
 } from "../types/types";
 import { importMembers } from "../utils/esm-utils";
@@ -50,6 +53,9 @@ export class Entity {
   subsets: {
     [key: string]: string[];
   };
+  subsetsInternal: {
+    [key: string]: string[];
+  };
   types: {
     [name: string]: z.ZodTypeAny;
   } = {};
@@ -98,8 +104,13 @@ export class Entity {
     // indexes
     this.indexes = indexes ?? [];
 
-    // subsets
-    this.subsets = subsets ?? {};
+    // subsets: SubsetField[]를 파싱하여 subsets(일반)와 subsetsInternal(internal)로 분리
+    this.subsets = {};
+    this.subsetsInternal = {};
+    for (const [key, fields] of Object.entries(subsets ?? {})) {
+      this.subsets[key] = fields.filter((f) => !isInternalSubsetField(f)).map(normalizeSubsetField);
+      this.subsetsInternal[key] = fields.filter(isInternalSubsetField).map(normalizeSubsetField);
+    }
 
     // enums
     this.enumLabels = enums ?? {};
@@ -117,11 +128,18 @@ export class Entity {
     };
   }
 
+  /**
+   * 쿼리용 서브셋 필드를 반환합니다 (subsets + subsetsInternal 합침)
+   */
+  getSubsetFieldsForQuery(subsetKey: string): string[] {
+    return [...(this.subsets[subsetKey] ?? []), ...(this.subsetsInternal[subsetKey] ?? [])];
+  }
+
   /**
    * 주어진 이름(subsetKey)의 subset을 실제로 가져오는 Puri 코드 구현체 string을 반환합니다.
    */
   getPuriSubsetQuery(subsetKey: string): string {
-    const subset = this.subsets[subsetKey];
+    const subset = this.getSubsetFieldsForQuery(subsetKey);
     const subsetQuery = this.resolveSubsetQuery("", subset);
 
     const lines: string[] = [];
@@ -148,7 +166,6 @@ export class Entity {
 
     // select - 입체적 구조로 생성
     const selectObj = this.buildNestedSelectObject(subsetQuery.select);
-
     lines.push(`.select(${this.stringifyNestedSelectObject(selectObj)});`);
 
     return lines.join("\n");
@@ -263,7 +280,7 @@ export class Entity {
   }
 
   getPuriLoaderQuery(subsetKey: string): string {
-    const subset = this.subsets[subsetKey];
+    const subset = this.getSubsetFieldsForQuery(subsetKey);
     const { loaders } = this.resolveSubsetQuery("", subset);
 
     const lines: string[] = [`[`];
@@ -370,7 +387,7 @@ export class Entity {
     subset SELECT/JOIN/LOADER 결과 리턴
   */
   getSubsetQuery(subsetKey: string): SubsetQuery {
-    const subset = this.subsets[subsetKey];
+    const subset = this.getSubsetFieldsForQuery(subsetKey);
 
     const result: SubsetQuery = this.resolveSubsetQuery("", subset);
     return result;
@@ -404,12 +421,16 @@ export class Entity {
         // 현재 테이블 필드셋은 select, virtual에 추가하고 리턴
         if (groupKey === "") {
           const realFields = fields.filter((field) => !isVirtualProp(this.propsDict[field]));
-          const virtualFields = fields.filter((field) => isVirtualProp(this.propsDict[field]));
+          // virtualType: "code" (또는 undefined)인 virtual prop만 r.virtual에 추가
+          // virtualType: "query"인 경우 사용자가 appendSelect로 직접 추가하므로 제외
+          const virtualCodeFields = fields.filter((field) =>
+            isVirtualCodeProp(this.propsDict[field]),
+          );
 
           if (prefix === "") {
             // 현재 테이블인 경우
             r.select = r.select.concat(realFields.map((field) => `${this.table}.${field}`));
-            r.virtual = r.virtual.concat(virtualFields);
+            r.virtual = r.virtual.concat(virtualCodeFields);
           } else {
             // 넘어온 테이블인 경우
             r.select = r.select.concat(
@@ -605,25 +626,12 @@ export class Entity {
       },
     );
 
-    return Object.keys(groups).flatMap((key) => {
+    return Object.keys(groups).flatMap<EntityPropNode, EntityPropNode[]>((key) => {
       const group = groups[key];
 
       // 일반 prop 처리
       if (key === "") {
         return group.map((propName) => {
-          // FIXME: 이거 나중에 없애야함
-          if (propName === "말도안되는프롭명__이거왜타입처리가꼬여서이러지?") {
-            return {
-              nodeType: "plain" as const,
-              prop: {
-                type: "string",
-                name: "uuid",
-                length: 128,
-              } as StringProp,
-              children: [],
-            } as EntityPropNode;
-          }
-
           const prop = entity.props.find((p) => p.name === propName);
           if (prop === undefined) {
             console.log({ propName, groups });
@@ -632,7 +640,6 @@ export class Entity {
           return {
             nodeType: "plain" as const,
             prop,
-            children: [],
           };
         });
       }
@@ -656,7 +663,6 @@ export class Entity {
               name: `${key}_id`,
               nullable: prop.nullable,
             },
-            children: [],
           };
         }
       }
@@ -671,9 +677,9 @@ export class Entity {
           : ("array" as const);
 
       return {
+        nodeType,
         prop,
         children,
-        nodeType,
       };
     });
   }
@@ -793,6 +799,17 @@ export class Entity {
   }
 
   toJson(): EntityJson {
+    // subsets와 subsetsInternal을 SubsetField[] 형태로 복원
+    const subsets: { [key: string]: SubsetField[] } = {};
+    for (const key of Object.keys(this.subsets)) {
+      const normalFields: SubsetField[] = this.subsets[key];
+      const internalFields: SubsetField[] = (this.subsetsInternal[key] ?? []).map((field) => ({
+        field,
+        internal: true,
+      }));
+      subsets[key] = [...normalFields, ...internalFields];
+    }
+
     return {
       id: this.id,
       parentId: this.parentId,
@@ -800,7 +817,7 @@ export class Entity {
       title: this.title,
       props: this.props,
       indexes: this.indexes,
-      subsets: this.subsets,
+      subsets,
       enums: this.enumLabels,
     };
   }
@@ -810,7 +827,12 @@ export class Entity {
     const subsetRows = this.getSubsetRows();
     this.subsets = Object.fromEntries(
       Object.entries(this.subsets).map(([subsetKey]) => {
-        return [subsetKey, this.subsetRowsToSubsetFields(subsetRows, subsetKey)];
+        return [subsetKey, this.subsetRowsToSubsetFields(subsetRows, subsetKey, false)];
+      }),
+    );
+    this.subsetsInternal = Object.fromEntries(
+      Object.entries(this.subsetsInternal).map(([subsetKey]) => {
+        return [subsetKey, this.subsetRowsToSubsetFields(subsetRows, subsetKey, true)];
       }),
     );
 
@@ -828,6 +850,7 @@ export class Entity {
 
   getSubsetRows(
     _subsets?: { [key: string]: string[] },
+    _subsetsInternal?: { [key: string]: string[] },
     prefixes: string[] = [],
   ): EntitySubsetRow[] {
     if (prefixes.length > 10) {
@@ -835,16 +858,23 @@ export class Entity {
     }
 
     const subsets = _subsets ?? this.subsets;
+    const subsetsInternal = _subsetsInternal ?? this.subsetsInternal;
     const subsetKeys = Object.keys(subsets);
     const allFields = unique(subsetKeys.flatMap((key) => subsets[key]));
+    // internal 필드도 allFields에 포함 (relation 탐색용)
+    const allInternalFields = unique(subsetKeys.flatMap((key) => subsetsInternal[key] ?? []));
+    const combinedFields = unique([...allFields, ...allInternalFields]);
 
     return this.props.map((prop) => {
       if (
         prop.type === "relation" &&
-        allFields.find((f) => f.startsWith(`${[...prefixes, prop.name].join(".")}.`))
+        combinedFields.find((f) => f.startsWith(`${[...prefixes, prop.name].join(".")}.`))
       ) {
         const relEntity = EntityManager.get(prop.with);
-        const children = relEntity.getSubsetRows(subsets, [...prefixes, `${prop.name}`]);
+        const children = relEntity.getSubsetRows(subsets, subsetsInternal, [
+          ...prefixes,
+          `${prop.name}`,
+        ]);
 
         return {
           field: prop.name,
@@ -857,9 +887,15 @@ export class Entity {
               return [subsetKey, children.every((child) => child.has[subsetKey] === true)];
             }),
           ),
+          isInternal: Object.fromEntries(
+            subsetKeys.map((subsetKey) => {
+              return [subsetKey, children.every((child) => child.isInternal[subsetKey] === true)];
+            }),
+          ),
         };
       }
 
+      const field = [...prefixes, prop.name].join(".");
       return {
         field: prop.name,
         children: [],
@@ -869,22 +905,35 @@ export class Entity {
           subsetKeys.map((subsetKey) => {
             const subsetFields = subsets[subsetKey];
             const has = subsetFields.some((f) => {
-              const field = [...prefixes, prop.name].join(".");
               return f === field || f.startsWith(`${field}.`);
             });
             return [subsetKey, has];
           }),
         ),
+        isInternal: Object.fromEntries(
+          subsetKeys.map((subsetKey) => {
+            const internalFields = subsetsInternal[subsetKey] ?? [];
+            const isInternal = internalFields.some((f) => {
+              return f === field || f.startsWith(`${field}.`);
+            });
+            return [subsetKey, isInternal];
+          }),
+        ),
       };
     });
   }
 
-  subsetRowsToSubsetFields(subsetRows: EntitySubsetRow[], subsetKey: string): string[] {
+  subsetRowsToSubsetFields(
+    subsetRows: EntitySubsetRow[],
+    subsetKey: string,
+    internal: boolean = false,
+  ): string[] {
+    const hasKey = internal ? "isInternal" : "has";
     return subsetRows
       .map((subsetRow) => {
         if (subsetRow.children.length > 0) {
-          return this.subsetRowsToSubsetFields(subsetRow.children, subsetKey);
-        } else if (subsetRow.has[subsetKey]) {
+          return this.subsetRowsToSubsetFields(subsetRow.children, subsetKey, internal);
+        } else if (subsetRow[hasKey][subsetKey]) {
           return subsetRow.prefixes.concat(subsetRow.field).join(".");
         } else {
           return null;

package/src/index.ts

@@ -4,6 +4,7 @@ export type * from "./api/context";
 export * from "./api/decorators";
 export * from "./api/sonamu";
 export * from "./database/base-model";
+export * from "./database/base-model.types";
 export * from "./database/db";
 export * from "./database/puri";
 export * from "./database/puri.types";

package/src/tasks/workflow-manager.ts

@@ -77,10 +77,14 @@ export class WorkflowManager {
     }
   >;
 
-  private constructor(backend: BackendPostgres) {
+  // BackendPostgres에서 처리하는 것들이 있어서 Knex 커넥션이 아니라 설정값을 넣어줘야함.
+  constructor(dbConf: Knex.Config, runMigrations: boolean = true) {
+    const backend = new BackendPostgres(dbConf, { runMigrations });
+
     this.#backend = backend;
     this.#ow = new OpenWorkflow({ backend });
     this.#worker = null;
+
     this.#workflowsMap = new Map();
     this.#scheduledTasks = new Map();
   }
@@ -283,9 +287,18 @@ export class WorkflowManager {
   }
 
   // Worker를 설정 후 시작
-  async setupWorker(options: WorkflowOptions) {
+  setupWorker(options: WorkflowOptions) {
     this.#worker = this.#ow.newWorker(options);
-    await this.#worker.start();
+  }
+
+  // Worker를 초기화
+  async startWorker() {
+    if (!this.#worker) {
+      return;
+    }
+
+    await this.#backend.initialize();
+    await this.#worker?.start();
   }
 
   // Worker를 중지
@@ -318,13 +331,4 @@ export class WorkflowManager {
   [Symbol.asyncDispose]() {
     return this.destroy();
   }
-
-  // BackendPostgres에서 처리하는 것들이 있어서 Knex 커넥션이 아니라 설정값을 넣어줘야함.
-  static async create(
-    dbConf: Knex.Config,
-    runMigrations: boolean = true,
-  ): Promise<WorkflowManager> {
-    const backend = await BackendPostgres.connect(dbConf, { runMigrations });
-    return new WorkflowManager(backend);
-  }
 }

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

@@ -4,7 +4,12 @@ import { Sonamu } from "../../api";
 import type { Entity } from "../../entity/entity";
 import { EntityManager } from "../../entity/entity-manager";
 import { Naite } from "../../naite/naite";
-import { type EntityIndex, type EntityPropNode, isVirtualProp } from "../../types/types";
+import {
+  type EntityIndex,
+  type EntityPropNode,
+  isVirtualCodeProp,
+  isVirtualQueryProp,
+} from "../../types/types";
 import { nonNullable } from "../../utils/utils";
 import { Template } from "../template";
 import { propNodeToZodTypeDef, zodTypeToZodCode } from "../zod-converter";
@@ -171,9 +176,14 @@ export class Template__generated extends Template {
     // TODO: GIN/GiST 인덱스 생성된 컬럼 추출
     const fulltextColumns: EntityIndex["columns"][] = [];
 
-    // virtual props
+    // virtual props (virtualType: "code" 또는 undefined인 것만 포함)
     const virtualProps = entity.props
-      .filter((prop) => isVirtualProp(prop))
+      .filter((prop) => isVirtualCodeProp(prop))
+      .map((prop) => prop.name);
+
+    // query virtual props (virtualType: "query"인 것만 포함)
+    const virtualQueryProps = entity.props
+      .filter((prop) => isVirtualQueryProp(prop))
       .map((prop) => prop.name);
 
     /**
@@ -209,6 +219,7 @@ export class Template__generated extends Template {
     const hasMetadata =
       fulltextColumns.length > 0 ||
       virtualProps.length > 0 ||
+      virtualQueryProps.length > 0 ||
       hasDefaultColumns.length > 0 ||
       generatedColumns.length > 0 ||
       hasVectorColumns.length > 0;
@@ -226,6 +237,9 @@ export class Template__generated extends Template {
               (virtualProps.length > 0
                 ? `readonly __virtual__: readonly [${virtualProps.map((prop) => `"${prop}"`).join(", ")}],`
                 : "") +
+              (virtualQueryProps.length > 0
+                ? `readonly __virtual_query__: readonly [${virtualQueryProps.map((prop) => `"${prop}"`).join(", ")}],`
+                : "") +
               (hasDefaultColumns.length > 0
                 ? `readonly __hasDefault__: readonly [${hasDefaultColumns
                     .map((col) => `"${col}"`)

package/src/types/types.ts

@@ -104,6 +104,7 @@ export type UuidArrayProp = CommonProp & {
 export type VirtualProp = CommonProp & {
   type: "virtual";
   id: string;
+  virtualType?: "query" | "code"; // default: "code"
 }; // PG: none / TS: any(id) / JSON: any
 export type VectorProp = CommonProp & {
   type: "vector";
@@ -264,6 +265,17 @@ export type EntityIndex = {
    */
   lists?: number;
 };
+
+// SubsetField 타입: string 또는 internal 옵션이 있는 객체
+export type SubsetField = string | { field: string; internal?: boolean };
+
+export function normalizeSubsetField(f: SubsetField): string {
+  return typeof f === "string" ? f : f.field;
+}
+export function isInternalSubsetField(f: SubsetField): boolean {
+  return typeof f !== "string" && f.internal === true;
+}
+
 export type EntityJson = {
   id: string;
   parentId?: string;
@@ -272,7 +284,7 @@ export type EntityJson = {
   props: EntityProp[];
   indexes: EntityIndex[];
   subsets: {
-    [subset: string]: string[];
+    [subset: string]: SubsetField[];
   };
   enums: {
     [enumId: string]: {
@@ -285,6 +297,9 @@ export type EntitySubsetRow = {
   has: {
     [key: string]: boolean;
   };
+  isInternal: {
+    [key: string]: boolean;
+  };
   children: EntitySubsetRow[];
   prefixes: string[];
   relationEntity?: string;
@@ -413,6 +428,14 @@ export function isJsonProp(p: unknown): p is JsonProp {
 export function isVirtualProp(p: unknown): p is VirtualProp {
   return (p as VirtualProp)?.type === "virtual";
 }
+export function isVirtualCodeProp(p: unknown): p is VirtualProp {
+  if (!isVirtualProp(p)) return false;
+  return p.virtualType !== "query"; // undefined도 "code"로 취급
+}
+export function isVirtualQueryProp(p: unknown): p is VirtualProp {
+  if (!isVirtualProp(p)) return false;
+  return p.virtualType === "query";
+}
 export function isVectorSingleProp(p: unknown): p is VectorProp {
   return (p as VectorProp)?.type === "vector";
 }
@@ -951,6 +974,7 @@ const VirtualPropSchema = z
     ...BasePropFields,
     type: z.literal("virtual"),
     id: z.string(),
+    virtualType: z.enum(["query", "code"]).optional(),
   })
   .strict();
 
@@ -1172,7 +1196,12 @@ export const EntityJsonSchema = z
     parentId: z.string().optional().describe("부모 Entity ID"),
     props: z.array(EntityPropSchema),
     indexes: z.array(EntityIndexSchema),
-    subsets: z.record(z.string(), z.array(z.string())),
+    subsets: z.record(
+      z.string(),
+      z.array(
+        z.union([z.string(), z.object({ field: z.string(), internal: z.boolean().optional() })]),
+      ),
+    ),
     enums: z.record(z.string(), z.record(z.string(), z.string())),
   })
   .strict();

package/src/ui/api.ts

@@ -345,15 +345,23 @@ export async function sonamuUIApiPlugin(fastify: FastifyInstance) {
           entityId: string;
           subsetKey: string;
           fields: string[];
+          fieldsInternal?: string[];
         };
       }>("/api/entity/modifySubset", async (request) => {
         return await waitForHMRCompleted(async () => {
-          const { entityId, subsetKey, fields } = request.body;
+          const { entityId, subsetKey, fields, fieldsInternal } = request.body;
           const entity = EntityManager.get(entityId);
           entity.subsets[subsetKey] = fields;
+          if (fieldsInternal !== undefined) {
+            if (fieldsInternal.length > 0) {
+              entity.subsetsInternal[subsetKey] = fieldsInternal;
+            } else {
+              delete entity.subsetsInternal[subsetKey];
+            }
+          }
           await entity.save();
 
-          return { updated: fields };
+          return { updated: fields, updatedInternal: fieldsInternal };
         });
       });
 
@@ -367,6 +375,7 @@ export async function sonamuUIApiPlugin(fastify: FastifyInstance) {
           const { entityId, subsetKey } = request.body;
           const entity = EntityManager.get(entityId);
           delete entity.subsets[subsetKey];
+          delete entity.subsetsInternal[subsetKey];
           await entity.save();
 
           return 1;