sonamu 0.4.10 → 0.4.12

package/dist/{model-BF9CDic2.d.mts → model-DWoinpJ7.d.ts}

@@ -469,11 +469,59 @@ declare const TemplateOptions: z.ZodObject<{
         entityId: string;
     }>;
     service: z.ZodObject<{
-        entityId: z.ZodString;
+        namesRecord: z.ZodObject<{
+            fs: z.ZodString;
+            fsPlural: z.ZodString;
+            camel: z.ZodString;
+            camelPlural: z.ZodString;
+            capital: z.ZodString;
+            capitalPlural: z.ZodString;
+            upper: z.ZodString;
+            constant: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            fs: string;
+            fsPlural: string;
+            camel: string;
+            camelPlural: string;
+            capital: string;
+            capitalPlural: string;
+            upper: string;
+            constant: string;
+        }, {
+            fs: string;
+            fsPlural: string;
+            camel: string;
+            camelPlural: string;
+            capital: string;
+            capitalPlural: string;
+            upper: string;
+            constant: string;
+        }>;
+        modelTsPath: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        entityId: string;
+        namesRecord: {
+            fs: string;
+            fsPlural: string;
+            camel: string;
+            camelPlural: string;
+            capital: string;
+            capitalPlural: string;
+            upper: string;
+            constant: string;
+        };
+        modelTsPath: string;
     }, {
-        entityId: string;
+        namesRecord: {
+            fs: string;
+            fsPlural: string;
+            camel: string;
+            camelPlural: string;
+            capital: string;
+            capitalPlural: string;
+            upper: string;
+            constant: string;
+        };
+        modelTsPath: string;
     }>;
     view_list: z.ZodObject<{
         entityId: z.ZodString;
@@ -611,7 +659,17 @@ declare const TemplateOptions: z.ZodObject<{
         entityId: string;
     };
     service: {
-        entityId: string;
+        namesRecord: {
+            fs: string;
+            fsPlural: string;
+            camel: string;
+            camelPlural: string;
+            capital: string;
+            capitalPlural: string;
+            upper: string;
+            constant: string;
+        };
+        modelTsPath: string;
     };
     view_list: {
         entityId: string;
@@ -683,7 +741,17 @@ declare const TemplateOptions: z.ZodObject<{
         entityId: string;
     };
     service: {
-        entityId: string;
+        namesRecord: {
+            fs: string;
+            fsPlural: string;
+            camel: string;
+            camelPlural: string;
+            capital: string;
+            capitalPlural: string;
+            upper: string;
+            constant: string;
+        };
+        modelTsPath: string;
     };
     view_list: {
         entityId: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sonamu",
-  "version": "0.4.10",
+  "version": "0.4.12",
   "description": "Sonamu — TypeScript Fullstack API Framework",
   "keywords": [
     "typescript",

package/src/api/base-frame.ts

@@ -0,0 +1,14 @@
+import { Knex } from "knex";
+import { DB } from "../database/db";
+import { DBPreset } from "../database/types";
+import { UpsertBuilder } from "../database/upsert-builder";
+
+export abstract class BaseFrameClass {
+  getDB(which: DBPreset): Knex {
+    return DB.getDB(which) as Knex;
+  }
+
+  getUpsertBuilder() {
+    return new UpsertBuilder<"knex">();
+  }
+}

package/src/api/decorators.ts

@@ -49,8 +49,9 @@ export function api(options: ApiDecoratorOptions = {}) {
   return function (target: Object, propertyKey: string) {
     const modelName = target.constructor.name.match(/(.+)Class$/)![1];
     const methodName = propertyKey;
+
     const defaultPath = `/${inflection.camelize(
-      modelName.replace(/Model$/, ""),
+      modelName.replace(/Model$/, "").replace(/Frame$/, ""),
       true
     )}/${inflection.camelize(propertyKey, true)}`;
 

package/src/index.ts

@@ -2,6 +2,7 @@ export * from "./api/code-converters";
 export * from "./api/context";
 export * from "./api/decorators";
 export * from "./api/sonamu";
+export * from "./api/base-frame";
 export * from "./database/db";
 export * from "./database/upsert-builder";
 export * from "./database/types";

package/src/syncer/syncer.ts

@@ -5,7 +5,7 @@ import crypto from "crypto";
 import equal from "fast-deep-equal";
 import _ from "lodash";
 import inflection from "inflection";
-import { EntityManager } from "../entity/entity-manager";
+import { EntityManager, EntityNamesRecord } from "../entity/entity-manager";
 import ts from "typescript";
 import {
   ApiParam,
@@ -79,7 +79,13 @@ import { Template__kysely_interface } from "../templates/kysely_types.template";
 import { DB } from "../database/db";
 import { setTimeout as setTimeoutPromises } from "timers/promises";
 
-type FileType = "model" | "types" | "functions" | "generated" | "entity";
+type FileType =
+  | "model"
+  | "types"
+  | "functions"
+  | "generated"
+  | "entity"
+  | "frame";
 type GlobPattern = {
   [key in FileType]: string;
 };
@@ -200,7 +206,7 @@ export class Syncer {
     // 다른 부분 찾아 액션
     const diffGroups = _.groupBy(diffFiles, (r) => {
       const matched = r.match(
-        /\.(model|types|functions|entity|generated)\.[tj]s/
+        /\.(model|types|functions|entity|generated|frame)\.[tj]s/
       );
       return matched![1];
     }) as unknown as DiffGroups;
@@ -255,12 +261,44 @@ export class Syncer {
     }
 
     // 트리거: model
-    if (diffTypes.includes("model")) {
-      const entityIds = this.getEntityIdFromPath(diffGroups["model"]);
+    if (diffTypes.includes("model") || diffTypes.includes("frame")) {
       console.log("// 액션: 서비스 생성");
-      await this.actionGenerateServices(entityIds);
+      const mergedGroup = [
+        ...(diffGroups["model"] ?? []),
+        ...(diffGroups["frame"] ?? []),
+      ];
+      const params: { namesRecord: EntityNamesRecord; modelTsPath: string }[] =
+        mergedGroup.map((modelPath) => {
+          if (modelPath.endsWith(".model.js")) {
+            const entityId = this.getEntityIdFromPath([modelPath])[0];
+            return {
+              namesRecord: EntityManager.getNamesFromId(entityId),
+              modelTsPath: path.join(
+                Sonamu.apiRootPath,
+                modelPath
+                  .replace("/dist/", "/src/")
+                  .replace(".model.js", ".model.ts")
+              ),
+            };
+          }
+          if (modelPath.endsWith("frame.js")) {
+            const [, frameName] = modelPath.match(/.+\/(.+)\.frame.js$/) ?? [];
+            return {
+              namesRecord: EntityManager.getNamesFromId(frameName),
+              modelTsPath: path.join(
+                Sonamu.apiRootPath,
+                modelPath
+                  .replace("/dist/", "/src/")
+                  .replace(".frame.js", ".frame.ts")
+              ),
+            };
+          }
+          throw new Error("not reachable");
+        });
+      await this.actionGenerateServices(params);
+
       console.log("// 액션: HTTP파일 생성");
-      await this.actionGenerateHttps(entityIds);
+      await this.actionGenerateHttps();
     }
 
     // 저장
@@ -292,19 +330,18 @@ export class Syncer {
       .flat();
   }
 
-  async actionGenerateServices(entityIds: string[]): Promise<string[]> {
+  async actionGenerateServices(
+    paramsArray: {
+      namesRecord: EntityNamesRecord;
+      modelTsPath: string;
+    }[]
+  ): Promise<string[]> {
     return (
       await Promise.all(
-        entityIds.map(async (entityId) =>
-          this.generateTemplate(
-            "service",
-            {
-              entityId,
-            },
-            {
-              overwrite: true,
-            }
-          )
+        paramsArray.map(async (params) =>
+          this.generateTemplate("service", params, {
+            overwrite: true,
+          })
         )
       )
     )
@@ -312,10 +349,10 @@ export class Syncer {
       .flat();
   }
 
-  async actionGenerateHttps(entityIds: string[]): Promise<string[]> {
+  async actionGenerateHttps(): Promise<string[]> {
     const [res] = await this.generateTemplate(
       "generated_http",
-      { entityId: entityIds[0] },
+      {},
       { overwrite: true }
     );
     return res;
@@ -383,6 +420,7 @@ export class Syncer {
       functions: Sonamu.apiRootPath + "/src/application/**/*.functions.ts",
       /* compiled-JS 체크 */
       model: Sonamu.apiRootPath + "/dist/application/**/*.model.js",
+      frame: Sonamu.apiRootPath + "/dist/application/**/*.frame.js",
     };
 
     const filePaths = (
@@ -525,6 +563,12 @@ export class Syncer {
           method.methodName === api.methodName
       );
     });
+    if (currentModelApis.length === 0) {
+      // const p = path.join(tmpdir(), "sonamu-syncer-error.json");
+      // writeFileSync(p, JSON.stringify(registeredApis, null, 2));
+      // execSync(`open ${p}`);
+      throw new Error(`현재 파일에 사전 등록된 API가 없습니다. ${filePath}`);
+    }
 
     // 등록된 API에 현재 메소드 타입 정보 확장
     const extendedApis = currentModelApis.map((api) => {
@@ -722,7 +766,7 @@ export class Syncer {
   async autoloadApis() {
     const pathPattern = path.join(
       Sonamu.apiRootPath,
-      "/src/application/**/*.model.ts"
+      "/src/application/**/*.{model,frame}.ts"
     );
     // console.debug(chalk.yellow(`autoload:APIs @ ${pathPattern}`));
 
@@ -737,7 +781,7 @@ export class Syncer {
   async autoloadModels(): Promise<{ [modelName: string]: unknown }> {
     const pathPattern = path.join(
       Sonamu.apiRootPath,
-      "dist/application/**/*.model.js"
+      "dist/application/**/*.{model,frame}.js"
     );
     // console.debug(chalk.yellow(`autoload:models @ ${pathPattern}`));
 
@@ -752,7 +796,9 @@ export class Syncer {
       .map(({ imported }) => Object.entries(imported))
       .flat();
     this.models = Object.fromEntries(
-      functions.filter(([name]) => name.endsWith("Model"))
+      functions.filter(
+        ([name]) => name.endsWith("Model") || name.endsWith("Frame")
+      )
     );
     return this.models;
   }
@@ -839,22 +885,13 @@ export class Syncer {
     const template: Template = this.getTemplate(key);
 
     let extra: unknown[] = [];
-    if (
-      ["service", "generated_http", "model", "view_list", "view_form"].includes(
-        key
-      )
-    ) {
-      const entityId = (options as TemplateOptions["service"]).entityId;
-
-      if (key === "service" || key === "generated_http") {
-        // service 필요 정보 (API 리스트)
-        const entity = EntityManager.get(entityId!);
-        const modelTsPath = `${path.join(
-          Sonamu.apiRootPath,
-          "/src/application"
-        )}/${entity.names.fs}/${entity.names.fs}.model.ts`;
-        extra = [await this.readApisFromFile(modelTsPath)];
-      } else if (key === "view_list" || key === "model") {
+    if (key === "service") {
+      // service 필요 정보 (API 리스트)
+      const { modelTsPath } = options as TemplateOptions["service"];
+      extra = [await this.readApisFromFile(modelTsPath)];
+    } else if (["model", "view_list", "view_form"].includes(key)) {
+      const entityId = (options as TemplateOptions["model"]).entityId;
+      if (key === "view_list" || key === "model") {
         // view_list 필요 정보 (컬럼 노드, 리스트파라미터 노드)
         const columnsNode = await this.getColumnsNode(entityId, "A");
         const listParamsZodType = await this.getZodTypeById(
@@ -1383,7 +1420,7 @@ export class Syncer {
     // generate schemas, types
     await Promise.all([
       this.actionGenerateSchemas(),
-      ...(form.entityId === undefined
+      ...(form.parentId === undefined
         ? [
             this.generateTemplate("init_types", {
               entityId: form.entityId,

package/src/templates/service.template.ts

@@ -1,7 +1,7 @@
 import inflection from "inflection";
 import _ from "lodash";
 import { TemplateOptions } from "../types/types";
-import { EntityManager, EntityNamesRecord } from "../entity/entity-manager";
+import { EntityNamesRecord } from "../entity/entity-manager";
 import { ApiParamType, ApiParam } from "../types/types";
 import {
   apiParamTypeToTsType,
@@ -24,9 +24,7 @@ export class Template__service extends Template {
     };
   }
 
-  render({ entityId }: TemplateOptions["service"], apis: ExtendedApi[]) {
-    const names = EntityManager.getNamesFromId(entityId);
-
+  render({ namesRecord }: TemplateOptions["service"], apis: ExtendedApi[]) {
     // 서비스 TypeSource
     const { lines, importKeys } = this.getTypeSource(apis);
 
@@ -36,7 +34,7 @@ export class Template__service extends Template {
     );
 
     return {
-      ...this.getTargetAndPath(names),
+      ...this.getTargetAndPath(namesRecord),
       body: lines.join("\n"),
       importKeys: importKeys.filter(
         (key) => ["ListResult"].includes(key) === false
@@ -154,7 +152,7 @@ export class Template__service extends Template {
           })
           .join("\n\n");
 
-        return `export namespace ${modelName.replace(/Model$/, "Service")} {
+        return `export namespace ${modelName.replace(/Model$/, "Service").replace(/Frame$/, "Service")} {
 ${methodCodes}
 }`;
       })

package/src/types/types.ts

@@ -686,7 +686,17 @@ export const TemplateOptions = z.object({
     entityId: z.string(),
   }),
   service: z.object({
-    entityId: z.string(),
+    namesRecord: z.object({
+      fs: z.string(),
+      fsPlural: z.string(),
+      camel: z.string(),
+      camelPlural: z.string(),
+      capital: z.string(),
+      capitalPlural: z.string(),
+      upper: z.string(),
+      constant: z.string(),
+    }),
+    modelTsPath: z.string(),
   }),
   view_list: z.object({
     entityId: z.string(),