sonamu 0.2.36 → 0.2.38

package/package.json

@@ -1,16 +1,29 @@
 {
   "name": "sonamu",
-  "version": "0.2.36",
+  "version": "0.2.38",
   "description": "Sonamu — TypeScript Fullstack API Framework",
   "keywords": [
     "typescript",
     "framework",
     "orm"
   ],
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    }
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
   "scripts": {
-    "dev": "yarn tsc -w -p ./tsconfig.json"
+    "dev": "yarn tsc -w -p ./tsconfig.json",
+    "build": "tsup --config ./tsup.config.js"
   },
   "license": "MIT",
   "author": {
@@ -22,7 +35,7 @@
     "type": "git",
     "url": "https://github.com/ping-alive/sonamu.git"
   },
-  "bin": "./dist/bin/cli.js",
+  "bin": "./dist/bin/cli-wrapper.mjs",
   "dependencies": {
     "chalk": "^4.1.2",
     "dotenv": "^16.0.2",
@@ -55,6 +68,7 @@
     "@types/uuid": "^8.3.4",
     "prettier": "^3.2.5",
     "source-map-support": "^0.5.21",
+    "tsup": "^8.1.0",
     "typescript": "^5.2.2"
   },
   "peerDependencies": {

package/src/api/decorators.ts

@@ -1,5 +1,5 @@
 import { HTTPMethods } from "fastify";
-import { camelize } from "inflection";
+import inflection from "inflection";
 import { ApiParam, ApiParamType } from "../types/types";
 
 export type ServiceClient =
@@ -49,10 +49,10 @@ export function api(options: ApiDecoratorOptions = {}) {
   return function (target: Object, propertyKey: string) {
     const modelName = target.constructor.name.match(/(.+)Class$/)![1];
     const methodName = propertyKey;
-    const defaultPath = `/${camelize(
+    const defaultPath = `/${inflection.camelize(
       modelName.replace(/Model$/, ""),
       true
-    )}/${camelize(propertyKey, true)}`;
+    )}/${inflection.camelize(propertyKey, true)}`;
 
     const api = {
       modelName,

package/src/api/sonamu.ts

@@ -14,7 +14,7 @@ import { DB, SonamuDBConfig } from "../database/db";
 import { BaseModel } from "../database/base-model";
 import { findApiRootPath } from "../utils/utils";
 import path from "path";
-import { existsSync, readFileSync } from "fs";
+import fs from "fs-extra";
 import { ApiDecoratorOptions } from "./decorators";
 
 export type SonamuConfig = {
@@ -128,11 +128,11 @@ class SonamuClass {
 
     this.apiRootPath = apiRootPath ?? (await findApiRootPath());
     const configPath = path.join(this.apiRootPath, "sonamu.config.json");
-    if (existsSync(configPath) === false) {
+    if (fs.existsSync(configPath) === false) {
       throw new Error(`Cannot find sonamu.config.json in ${configPath}`);
     }
     this.config = JSON.parse(
-      readFileSync(configPath).toString()
+      fs.readFileSync(configPath).toString()
     ) as SonamuConfig;
 
     // DB 로드

package/src/bin/cli-wrapper.ts

@@ -0,0 +1,34 @@
+#!/usr/bin/env ts-node
+
+import { spawnSync } from "child_process";
+import { resolve } from "path";
+import { existsSync, readFileSync } from "fs";
+
+const cjsPath = resolve(__dirname, "bin/cli.js");
+const esmPath = resolve(__dirname, "bin/cli.mjs");
+
+const isESM = () => {
+  const packageJsonPath = resolve(process.cwd(), "package.json");
+  if (existsSync(packageJsonPath)) {
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    return packageJson.type === "module";
+  }
+  return false;
+};
+
+const scriptPath = isESM() ? esmPath : cjsPath;
+
+if (!existsSync(scriptPath)) {
+  console.error(`Error: Script not found at ${scriptPath}`);
+  process.exit(1);
+}
+
+const result = spawnSync(
+  process.execPath,
+  [scriptPath, ...process.argv.slice(2)],
+  {
+    stdio: "inherit",
+  }
+);
+
+process.exit(result.status ?? 1);

package/src/bin/cli.ts

@@ -12,16 +12,10 @@ import { Migrator } from "../entity/migrator";
 import { FixtureManager } from "../testing/fixture-manager";
 import { tsicli } from "tsicli";
 import { execSync } from "child_process";
-import {
-  existsSync,
-  mkdirSync,
-  readdirSync,
-  unlinkSync,
-  writeFileSync,
-} from "fs";
+import fs from "fs-extra";
 import { Sonamu } from "../api";
 import knex, { Knex } from "knex";
-import { camelize } from "inflection";
+import inflection from "inflection";
 import prettier from "prettier";
 import { SMDManager } from "../smd/smd-manager";
 import process from "process";
@@ -241,11 +235,11 @@ async function fixture_sync() {
 
 async function stub_practice(name: string) {
   const practiceDir = path.join(Sonamu.apiRootPath, "src", "practices");
-  const fileNames = readdirSync(practiceDir);
+  const fileNames = fs.readdirSync(practiceDir);
 
   const maxSeqNo = (() => {
-    if (existsSync(practiceDir) === false) {
-      mkdirSync(practiceDir, { recursive: true });
+    if (fs.existsSync(practiceDir) === false) {
+      fs.mkdirSync(practiceDir, { recursive: true });
     }
 
     const filteredSeqs = fileNames
@@ -282,7 +276,7 @@ async function stub_practice(name: string) {
     `await BaseModel.destroy();`,
     `});`,
   ].join("\n");
-  writeFileSync(dstPath, code);
+  fs.writeFileSync(dstPath, code);
 
   execSync(`code ${dstPath}`);
 
@@ -338,7 +332,7 @@ async function smd_migration() {
     return Object.fromEntries(
       Object.entries(enumLabels).map(([enumLabelName, enumLabel]) => {
         const enumName =
-          entityId + camelize(enumLabelName.toLowerCase(), false);
+          entityId + inflection.camelize(enumLabelName.toLowerCase(), false);
         return [
           enumName,
           Object.fromEntries(
@@ -373,7 +367,7 @@ async function smd_migration() {
     const formatted = await prettier.format(JSON.stringify(entityJson), {
       parser: "json",
     });
-    writeFileSync(dstPath, formatted);
+    fs.writeFileSync(dstPath, formatted);
     console.log(chalk.blue(`CREATED: ${dstPath}`));
 
     // smd.ts, enums.ts, genereated.ts 삭제 (트랜스파일 된 js파일도 삭제)
@@ -421,11 +415,11 @@ async function smd_migration() {
       srcGeneratedPath,
       dstGeneratedPath,
     ].map((p) => {
-      if (existsSync(p) === false) {
+      if (fs.existsSync(p) === false) {
         console.log(chalk.yellow(`NOT FOUND: ${p}`));
         return;
       }
-      unlinkSync(p);
+      fs.unlinkSync(p);
       console.log(chalk.red(`DELETED: ${p}`));
     });
   }

package/src/database/base-model.ts

@@ -1,15 +1,15 @@
 import { DateTime } from "luxon";
 import { Knex } from "knex";
-import { chunk, groupBy, isObject, omit, set, uniq } from "lodash";
+import _ from "lodash";
 import { attachOnDuplicateUpdate } from "./knex-plugins/knex-on-duplicate-update";
 attachOnDuplicateUpdate();
 import { DBPreset, DB } from "./db";
 import { isCustomJoinClause, SubsetQuery } from "../types/types";
 import { BaseListParams } from "../utils/model";
-import { pluralize, underscore } from "inflection";
+import inflection from "inflection";
 import chalk from "chalk";
 import { UpsertBuilder } from "./upsert-builder";
-import { Parser } from "node-sql-parser";
+import SqlParser from "node-sql-parser";
 import { getTableName, getTableNamesFromWhere } from "../utils/sql-parser";
 
 export class BaseModelClass {
@@ -55,7 +55,7 @@ export class BaseModelClass {
       selectField = unqKeyFields[0];
       unqKeys = rows.map((row) => row[unqKeyFields[0]]);
     }
-    const chunks = chunk(unqKeys, chunkSize);
+    const chunks = _.chunk(unqKeys, chunkSize);
 
     let resultIds: number[] = [];
     for (let chunk of chunks) {
@@ -114,7 +114,7 @@ export class BaseModelClass {
             `${loader.manyJoin.toTable}.${loader.manyJoin.toCol}`
           )
           .whereIn(idColumn, fromIds)
-          .select(uniq([...loader.select, idColumn]));
+          .select(_.uniq([...loader.select, idColumn]));
 
         // ManyToMany에서 OneJoin이 있는 경우
         loader.oneJoins.map((join) => {
@@ -140,10 +140,10 @@ export class BaseModelClass {
       }
 
       // 불러온 row들을 참조ID 기준으로 분류 배치
-      const subRowGroups = groupBy(subRows, toCol);
+      const subRowGroups = _.groupBy(subRows, toCol);
       rows = rows.map((row) => {
         row[loader.as] = (subRowGroups[row[loader.manyJoin.idField]] ?? []).map(
-          (r) => omit(r, toCol)
+          (r) => _.omit(r, toCol)
         );
         return row;
       });
@@ -155,7 +155,7 @@ export class BaseModelClass {
     return rows.map((row: any) => {
       // nullable relation인 경우 관련된 필드가 전부 null로 생성되는 것 방지하는 코드
       const nestedKeys = Object.keys(row).filter((key) => key.includes("__"));
-      const groups = groupBy(nestedKeys, (key) => key.split("__")[0]);
+      const groups = _.groupBy(nestedKeys, (key) => key.split("__")[0]);
       const nullKeys = Object.keys(groups).filter(
         (key) =>
           groups[key].length > 1 &&
@@ -164,7 +164,7 @@ export class BaseModelClass {
 
       const hydrated = Object.keys(row).reduce((r, field) => {
         if (!field.includes("__")) {
-          if (Array.isArray(row[field]) && isObject(row[field][0])) {
+          if (Array.isArray(row[field]) && _.isObject(row[field][0])) {
             r[field] = this.hydrate(row[field]);
             return r;
           } else {
@@ -180,10 +180,10 @@ export class BaseModelClass {
             .slice(1)
             .map((part) => `[${part}]`)
             .join("");
-        set(
+        _.set(
           r,
           objPath,
-          row[field] && Array.isArray(row[field]) && isObject(row[field][0])
+          row[field] && Array.isArray(row[field]) && _.isObject(row[field][0])
             ? this.hydrate(row[field])
             : row[field]
         );
@@ -227,7 +227,8 @@ export class BaseModelClass {
     qb: Knex.QueryBuilder;
   }> {
     const db = _db ?? this.getDB(subset.startsWith("A") ? "w" : "r");
-    baseTable = baseTable ?? pluralize(underscore(this.modelName));
+    baseTable =
+      baseTable ?? inflection.pluralize(inflection.underscore(this.modelName));
     const queryMode =
       params.queryMode ?? (params.id !== undefined ? "list" : "both");
 
@@ -266,15 +267,17 @@ export class BaseModelClass {
       }
 
       const clonedQb = qb.clone().clear("order").clear("offset").clear("limit");
-      const parser = new Parser();
+      const parser = new SqlParser.Parser();
 
       // optmizeCountQuery가 true인 경우 다른 clause에 영향을 주지 않는 모든 join을 제외함
       if (optimizeCountQuery) {
         const parsedQuery = parser.astify(clonedQb.toQuery());
         const tables = getTableNamesFromWhere(parsedQuery);
         // where절에 사용되는 테이블의 조인을 위해 사용되는 테이블
-        const needToJoin = uniq(
-          tables.flatMap((table) => table.split("__").map((t) => pluralize(t)))
+        const needToJoin = _.uniq(
+          tables.flatMap((table) =>
+            table.split("__").map((t) => inflection.pluralize(t))
+          )
         );
         applyJoinClause(
           clonedQb,

package/src/database/db.ts

@@ -21,7 +21,7 @@ class DBClass {
   async readKnexfile(): Promise<SonamuDBConfig> {
     const dbConfigPath: string = path.join(
       Sonamu.apiRootPath,
-      "/dist/configs/db"
+      "/dist/configs/db.js"
     );
     try {
       const knexfileModule = await import(dbConfigPath);

package/src/database/upsert-builder.ts

@@ -1,5 +1,5 @@
 import { v4 as uuidv4 } from "uuid";
-import { defaults, groupBy, uniq } from "lodash";
+import _ from "lodash";
 import { Knex } from "knex";
 import { EntityManager } from "../entity/entity-manager";
 import { nonNullable } from "../utils/utils";
@@ -178,7 +178,7 @@ export class UpsertBuilder {
     }
 
     // 내부 참조 있는 경우 필터하여 분리
-    const groups = groupBy(table.rows, (row) =>
+    const groups = _.groupBy(table.rows, (row) =>
       Object.entries(row).some(([, value]) => isRefField(value))
         ? "selfRef"
         : "normal"
@@ -212,14 +212,14 @@ export class UpsertBuilder {
       }
     );
 
-    const extractFields = uniq(references).map(
+    const extractFields = _.uniq(references).map(
       (reference) => reference.split(".")[1]
     );
 
     // UUID 기준으로 id 추출
     const uuids = table.rows.map((row) => row.uuid);
     const upsertedRows = await wdb(tableName)
-      .select(uniq(["uuid", "id", ...extractFields]))
+      .select(_.uniq(["uuid", "id", ...extractFields]))
       .whereIn("uuid", uuids);
     const uuidMap = new Map<string, any>(
       upsertedRows.map((row: any) => [row.uuid, row])
@@ -263,7 +263,7 @@ export class UpsertBuilder {
       where?: string;
     }
   ): Promise<void> {
-    options = defaults(options, {
+    options = _.defaults(options, {
       chunkSize: 500,
       where: "id",
     });

package/src/entity/entity-manager.ts

@@ -1,12 +1,12 @@
 import chalk from "chalk";
-import { glob } from "glob";
-import { dasherize, underscore, pluralize, camelize } from "inflection";
+import glob from "glob";
+import inflection from "inflection";
 import _ from "lodash";
 import path from "path";
 import { Entity } from "./entity";
 import { EntityJson } from "../types/types";
 import { Sonamu } from "../api/sonamu";
-import { readFileSync } from "fs";
+import fs from "fs-extra";
 
 export type EntityNamesRecord = Record<
   | "fs"
@@ -41,10 +41,10 @@ class EntityManagerClass {
     !doSilent && console.log(chalk.yellow(`autoload ${pathPattern}`));
 
     return new Promise((resolve) => {
-      glob(path.resolve(pathPattern!), (_err, files) => {
+      glob.glob(path.resolve(pathPattern!), (_err, files) => {
         Promise.all(
           files.map(async (file) => {
-            this.register(JSON.parse(readFileSync(file).toString()));
+            this.register(JSON.parse(fs.readFileSync(file).toString()));
           })
         ).then(() => {
           resolve("ok");
@@ -139,19 +139,21 @@ class EntityManagerClass {
   getNamesFromId(entityId: string): EntityNamesRecord {
     // entityId가 단복수 동형 단어인 경우 List 붙여서 생성
     const pluralized =
-      pluralize(entityId) === entityId
+      inflection.pluralize(entityId) === entityId
         ? `${entityId}List`
-        : pluralize(entityId);
+        : inflection.pluralize(entityId);
 
     return {
-      fs: dasherize(underscore(entityId)).toLowerCase(),
-      fsPlural: dasherize(underscore(pluralized)).toLowerCase(),
-      camel: camelize(entityId, true),
-      camelPlural: camelize(pluralized, true),
+      fs: inflection.dasherize(inflection.underscore(entityId)).toLowerCase(),
+      fsPlural: inflection
+        .dasherize(inflection.underscore(pluralized))
+        .toLowerCase(),
+      camel: inflection.camelize(entityId, true),
+      camelPlural: inflection.camelize(pluralized, true),
       capital: entityId,
       capitalPlural: pluralized,
       upper: entityId.toUpperCase(),
-      constant: underscore(entityId).toUpperCase(),
+      constant: inflection.underscore(entityId).toUpperCase(),
     };
   }
 }

package/src/entity/entity-utils.ts

@@ -1,4 +1,4 @@
-import { camelize } from "inflection";
+import inflection from "inflection";
 import {
   BelongsToOneRelationProp,
   BigIntegerProp,
@@ -208,7 +208,7 @@ function enums(
   return {
     name,
     type: "enum",
-    id: option.id ?? `$Model${camelize(name)}`,
+    id: option.id ?? `$Model${inflection.camelize(name)}`,
     ...option,
   };
 }

package/src/entity/entity.ts

@@ -1,6 +1,5 @@
-import { groupBy, uniq } from "lodash";
+import _ from "lodash";
 import { EntityManager as EntityManager } from "./entity-manager";
-import { dasherize, pluralize, underscore } from "inflection";
 import {
   EntityProp,
   RelationProp,
@@ -20,7 +19,7 @@ import {
 } from "../types/types";
 import inflection from "inflection";
 import path from "path";
-import { existsSync, writeFileSync } from "fs";
+import fs from "fs-extra";
 import { z } from "zod";
 import { Sonamu } from "../api/sonamu";
 import prettier from "prettier";
@@ -73,7 +72,7 @@ export class Entity {
     this.id = id;
     this.parentId = parentId;
     this.title = title ?? this.id;
-    this.table = table ?? underscore(pluralize(id));
+    this.table = table ?? inflection.underscore(inflection.pluralize(id));
 
     // props
     if (props) {
@@ -128,8 +127,10 @@ export class Entity {
 
     // names
     this.names = {
-      parentFs: dasherize(underscore(parentId ?? id)).toLowerCase(),
-      fs: dasherize(underscore(id)).toLowerCase(),
+      parentFs: inflection
+        .dasherize(inflection.underscore(parentId ?? id))
+        .toLowerCase(),
+      fs: inflection.dasherize(inflection.underscore(id)).toLowerCase(),
       module: id,
     };
 
@@ -158,7 +159,7 @@ export class Entity {
     prefix = prefix.replace(/\./g, "__");
 
     // 서브셋을 1뎁스만 분리하여 그룹핑
-    const subsetGroup = groupBy(fields, (field) => {
+    const subsetGroup = _.groupBy(fields, (field) => {
       if (field.includes(".")) {
         const [rel] = field.split(".");
         return rel;
@@ -271,7 +272,7 @@ export class Entity {
                 to = `${joinAs}.id`;
               } else {
                 from = `${fromTable}.id`;
-                to = `${joinAs}.${underscore(
+                to = `${joinAs}.${inflection.underscore(
                   this.names.fs.replace(/\-/g, "_")
                 )}_id`;
               }
@@ -302,6 +303,7 @@ export class Entity {
                 manyJoin: loader.manyJoin,
                 oneJoins: loader.oneJoins,
                 select: loader.select,
+                loaders: loader.loaders,
               };
             });
 
@@ -575,7 +577,7 @@ export class Entity {
       `dist/application/${typesModulePath}.js`
     );
 
-    if (existsSync(typesFileDistPath)) {
+    if (fs.existsSync(typesFileDistPath)) {
       const importPath = path.relative(__dirname, typesFileDistPath);
       import(importPath).then((t) => {
         this.types = Object.keys(t).reduce((result, key) => {
@@ -629,7 +631,7 @@ export class Entity {
       `src/application/${this.names.parentFs}/${this.names.fs}.entity.json`
     );
     const json = this.toJson();
-    writeFileSync(
+    fs.writeFileSync(
       jsonPath,
       await prettier.format(JSON.stringify(json), {
         parser: "json",
@@ -650,7 +652,7 @@ export class Entity {
 
     const subsets = _subsets ?? this.subsets;
     const subsetKeys = Object.keys(subsets);
-    const allFields = uniq(subsetKeys.map((key) => subsets[key]).flat());
+    const allFields = _.uniq(subsetKeys.map((key) => subsets[key]).flat());
 
     return this.props.map((prop) => {
       if (