sonamu 0.7.15 → 0.7.17

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/shared/app.shared.ts.txt

@@ -322,7 +322,7 @@ export function useSSEStream<T extends Record<string, any>>(
 
       // URL에 파라미터 추가 - 절대 URL로 변환
       const queryString = qs.stringify(params);
-      const baseUrl = url.startsWith("http") ? url : `https://dev.amrintl.com${url}`;
+      const baseUrl = url.startsWith("http") ? url : `$[[baseUrl]]${url}`;
       const fullUrl = queryString ? `${baseUrl}?${queryString}` : baseUrl;
 
       const eventSource = new EventSource(fullUrl);

package/src/shared/web.shared.ts.txt

@@ -108,49 +108,6 @@ export const SonamuSemanticParams = z
   .partial();
 export type SonamuSemanticParams = z.infer<typeof SonamuSemanticParams>;
 
-/*
-  SWR
-*/
-export type SwrOptions = {
-  conditional?: () => boolean;
-};
-export type SWRError = {
-  name: string;
-  message: string;
-  statusCode: number;
-};
-export async function swrFetcher(args: [string, object]): Promise<any> {
-  try {
-    const [url, params] = args;
-    const res = await axios.get(`${url}?${qs.stringify(params)}`);
-    return res.data;
-  } catch (e: any) {
-    const error: any = new Error(e.response.data.message ?? e.response.message ?? "Unknown");
-    error.statusCode = e.response?.data.statusCode ?? e.response.status;
-    throw error;
-  }
-}
-export async function swrPostFetcher(args: [string, object]): Promise<any> {
-  try {
-    const [url, params] = args;
-    const res = await axios.post(url, params);
-    return res.data;
-  } catch (e: any) {
-    const error: any = new Error(e.response.data.message ?? e.response.message ?? "Unknown");
-    error.statusCode = e.response?.data.statusCode ?? e.response.status;
-    throw error;
-  }
-}
-export function handleConditional(
-  args: [string, object],
-  conditional?: () => boolean,
-): [string, object] | null {
-  if (conditional) {
-    return conditional() ? args : null;
-  }
-  return args;
-}
-
 /*
   Utils
 */

package/src/syncer/checksum.ts

@@ -48,22 +48,38 @@ export async function renewChecksums(): Promise<void> {
   await saveChecksums(calculatedChecksums);
 }
 
+export type FileOrData =
+  | {
+      path: PathLike;
+    }
+  | {
+      data: string;
+    };
+
 /**
  * 두 파일의 내용이 같은지 체크섬으로 비교합니다.
  * 만약 파일이 둘 중 하나라도 없다면 비교 불가로 false 반환합니다.
- * @param one 파일 경로
- * @param two 파일 경로
+ * @param one 파일 경로 혹은 데이터
+ * @param two 파일 경로 혹은 데이터
  * @returns boolean
  */
-export async function areFilesSame(one: PathLike, two: PathLike): Promise<boolean> {
-  if (!(await exists(one)) || !(await exists(two))) {
-    return false;
-  }
+export async function areFilesSame(...files: FileOrData[]): Promise<boolean> {
+  const checksums: string[] = [];
 
-  const oneChecksum = await getChecksumOfFile(one);
-  const twoChecksum = await getChecksumOfFile(two);
+  for (const file of files) {
+    if ("path" in file && !(await exists(file.path))) {
+      return false;
+    }
+
+    checksums.push(
+      "path" in file ? await getChecksumOfFile(file.path) : getChecksumOfData(file.data),
+    );
+  }
 
-  return oneChecksum === twoChecksum;
+  return checksums.every(
+    // 다음 체크섬과 비교, 만약 마지막 체크섬일 때는 첫 번째 체크섬과 비교
+    (checksum, index) => checksum === checksums[index === checksums.length - 1 ? 0 : index + 1],
+  );
 }
 
 async function getCurrentChecksums(): Promise<PathAndChecksum[]> {
@@ -125,6 +141,12 @@ async function saveChecksums(checksums: PathAndChecksum[]): Promise<void> {
   console.log("checksum saved", checksumFilePath);
 }
 
+function getChecksumOfData(data: string): string {
+  const hash = crypto.createHash("sha1");
+  hash.update(data);
+  return hash.digest("hex");
+}
+
 async function getChecksumOfFile(filePath: PathLike): Promise<string> {
   return new Promise<string>((resolve, reject) => {
     const hash = crypto.createHash("sha1");

package/src/syncer/code-generator.ts

@@ -115,7 +115,14 @@ async function resolveRenderedTemplate(
   const importDefs = importKeys
     .reduce(
       (r, importKey) => {
-        const modulePath = EntityManager.getModulePath(importKey);
+        let modulePath = importKey;
+        try {
+          modulePath = EntityManager.getModulePath(importKey);
+        } catch (error) {
+          throw new Error(
+            `[resolveRenderedTemplate:${key}] ${importKey} 모듈 경로 찾기 실패: ${error}`,
+          );
+        }
         let importPath = modulePath;
         if (modulePath.includes("/") || modulePath.includes(".")) {
           importPath = wrapIf(path.relative(path.dirname(filePath), modulePath), (p) => [

package/src/syncer/syncer.ts

@@ -161,6 +161,13 @@ export class Syncer {
   }
 
   async copySharedToTargets(targets: string[]): Promise<void> {
+    // 특정 변수 치환을 위해서 사용합니다.
+    const convertMap = {
+      baseUrl:
+        Sonamu.config.server.baseUrl ??
+        `http://${Sonamu.config.server.listen?.host ?? "localhost"}:${Sonamu.config.server.listen?.port ?? 3000}`,
+    };
+
     for (const target of targets) {
       // 지금 가져가려는 이 파일은 Sonamu 코드베이스의 일부입니다.
       // 그런데 dist 속 빌드된 소스 코드 파일이 필요한 것이 아니고, src에만 있는 텍스트 파일이 필요합니다.
@@ -178,6 +185,12 @@ export class Syncer {
         );
       }
 
+      const fullText = await readFile(srcPath, "utf-8");
+      const convertedText = Object.entries(convertMap).reduce(
+        (acc, [key, value]) => acc.replace(`$[[${key}]]`, value),
+        fullText,
+      );
+
       // 이건 프로젝트에 .ts 소스 코드 파일을 생성하는 것이므로 src의 .ts 경로로 갑니다.
       const destPath = path.join(Sonamu.appRootPath, target, "src/services/sonamu.shared.ts");
 
@@ -187,12 +200,11 @@ export class Syncer {
         console.warn(`Created directory '${path.dirname(destPath)}' because it did not exist.`);
       }
 
-      if (await areFilesSame(srcPath, destPath)) {
+      if (await areFilesSame({ data: convertedText }, { path: destPath })) {
         continue;
       }
 
-      await writeFile(destPath, await readFile(srcPath));
-
+      await writeFile(destPath, convertedText);
       !isTest() &&
         console.log(
           chalk.bold("Copied: ") + chalk.blue(path.relative(Sonamu.appRootPath, destPath)),
@@ -375,22 +387,7 @@ export class Syncer {
   }
 
   /**
-   * sonamu.generated.ts와 sonamu.generated.sso.ts를 생성합니다.
-   * @returns 생성된 파일 경로 배열.
-   */
-  async actionGenerateSchemas(): Promise<AbsolutePath[]> {
-    return (
-      await Promise.all([
-        generateTemplate("generated_sso", {}, { overwrite: true }),
-        generateTemplate("generated", {}, { overwrite: true }),
-      ])
-    )
-      .flat()
-      .flat();
-  }
-
-  /**
-   * *.service.ts를 생성합니다.
+   * services.generated.ts를 생성합니다.
    * @param paramsArray
    * @returns 생성된 파일 경로 배열.
    */
@@ -400,14 +397,29 @@ export class Syncer {
     }[],
   ): Promise<string[]> {
     Naite.t("actionGenerateServices", paramsArray);
+
+    // services.generated.ts 통합 파일 생성
+    const servicesFile = await generateTemplate(
+      "services",
+      {},
+      {
+        overwrite: true,
+      },
+    );
+
+    return [...servicesFile];
+  }
+
+  /**
+   * sonamu.generated.ts와 sonamu.generated.sso.ts를 생성합니다.
+   * @returns 생성된 파일 경로 배열.
+   */
+  async actionGenerateSchemas(): Promise<AbsolutePath[]> {
     return (
-      await Promise.all(
-        paramsArray.map(async (params) =>
-          generateTemplate("service", params as TemplateOptions["service"], {
-            overwrite: true,
-          }),
-        ),
-      )
+      await Promise.all([
+        generateTemplate("generated_sso", {}, { overwrite: true }),
+        generateTemplate("generated", {}, { overwrite: true }),
+      ])
     )
       .flat()
       .flat();

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/template/implementations/model.template.ts

@@ -63,7 +63,7 @@ class ${entityId}ModelClass extends BaseModelClass<
 > {
   modelName = "${entityId}";
 
-  @api({ httpMethod: "GET", clients: ["axios", "swr"], resourceName: "${entityId}" })
+  @api({ httpMethod: "GET", clients: ["axios", "tanstack-query"], resourceName: "${entityId}" })
   async findById<T extends ${entityId}SubsetKey>(
     subset: T,
     id: number
@@ -93,7 +93,7 @@ class ${entityId}ModelClass extends BaseModelClass<
     return rows[0] ?? null;
   }
 
-  @api({ httpMethod: "GET", clients: ["axios", "swr"], resourceName: "${names.capitalPlural}" })
+  @api({ httpMethod: "GET", clients: ["axios", "tanstack-query"], resourceName: "${names.capitalPlural}" })
   async findMany<T extends ${entityId}SubsetKey, LP extends ${entityId}ListParams>(
     subset: T,
     rawParams?: LP,
@@ -156,7 +156,7 @@ class ${entityId}ModelClass extends BaseModelClass<
     });
   }
 
-  @api({ httpMethod: "POST" })
+  @api({ httpMethod: "POST", clients: ["axios", "tanstack-mutation"] })
   async save(
     spa: ${entityId}SaveParams[]
   ): Promise<number[]> {
@@ -175,7 +175,7 @@ class ${entityId}ModelClass extends BaseModelClass<
     });
   }
 
-  @api({ httpMethod: "POST", guards: [ "admin" ] })
+  @api({ httpMethod: "POST", clients: ["axios", "tanstack-mutation"], guards: [ "admin" ] })
   async del(ids: number[]): Promise<number> {
     const wdb = this.getPuri("w");