sonamu 0.4.13 → 0.5.0

package/src/templates/generated.template.ts

@@ -171,9 +171,21 @@ export class Template__generated extends Template {
 
     const schemaBody = propNodeToZodTypeDef(propNode, importKeys);
 
+    // fulltext index에 포함된 컬럼들 추출
+    const fulltextColumns = _.uniq(
+      entity.indexes
+        .filter((index) => index.type === "fulltext")
+        .flatMap((index) => index.columns)
+    );
+
     const lines = [
       `export const ${schemaName} = ${schemaBody}`,
-      `export type ${schemaName} = z.infer<typeof ${schemaName}>`,
+      `export type ${schemaName} = z.infer<typeof ${schemaName}>` +
+        (fulltextColumns.length > 0
+          ? ` & { readonly __fulltext__: readonly [${fulltextColumns
+              .map((col) => `"${col}"`)
+              .join(", ")}] }`
+          : ""),
     ];
 
     return {

package/src/templates/generated_http.template.ts

@@ -84,7 +84,7 @@ export class Template__generated_http extends Template {
         ])
       );
     } else if (zodType instanceof z.ZodArray) {
-      return [this.zodTypeToReqDefault(zodType.element, name)];
+      return [this.zodTypeToReqDefault((zodType as z.ZodArray<z.ZodType>).element, name)];
     } else if (zodType instanceof z.ZodString) {
       if (name.endsWith("_at") || name.endsWith("_date") || name === "range") {
         return "2000-01-01";
@@ -95,40 +95,43 @@ export class Template__generated_http extends Template {
       if (name === "num") {
         return 24;
       }
-      return zodType.minValue ?? 0;
+
+      const minValue = zodType.minValue ?? 0;
+      return minValue > Number.MIN_SAFE_INTEGER  ? minValue : 0;
     } else if (zodType instanceof z.ZodBoolean) {
       return false;
     } else if (zodType instanceof z.ZodEnum) {
       return zodType.options[0];
     } else if (zodType instanceof z.ZodOptional) {
-      return this.zodTypeToReqDefault(zodType._def.innerType, name);
+      return this.zodTypeToReqDefault((zodType as z.ZodOptional<z.ZodType>).def.innerType, name);
     } else if (zodType instanceof z.ZodNullable) {
       return null;
     } else if (zodType instanceof z.ZodUnion) {
-      return this.zodTypeToReqDefault(zodType._def.options[0], name);
+      return this.zodTypeToReqDefault((zodType as z.ZodUnion<z.ZodType[]>).def.options[0], name);
     } else if (zodType instanceof z.ZodUnknown) {
       return "unknown";
     } else if (zodType instanceof z.ZodTuple) {
-      return zodType._def.items.map((item: any) =>
+      return zodType.def.items.map((item: any) =>
         this.zodTypeToReqDefault(item, name)
       );
     } else if (zodType instanceof z.ZodDate) {
       return "2000-01-01";
     } else if (zodType instanceof z.ZodLiteral) {
       return zodType.value;
-    } else if (zodType instanceof z.ZodEffects) {
-      return this.zodTypeToReqDefault(zodType._def.schema, name);
     } else if (zodType instanceof z.ZodRecord || zodType instanceof z.ZodMap) {
-      const key = this.zodTypeToReqDefault(zodType._def.keyType, name) as any;
-      const value = this.zodTypeToReqDefault(zodType._def.valueType, name);
+      const kvDef = (zodType as z.ZodRecord<any, z.ZodType> | z.ZodMap<z.ZodType, z.ZodType>).def
+      const key = this.zodTypeToReqDefault(kvDef.keyType, name) as any;
+      const value = this.zodTypeToReqDefault(kvDef.valueType, name);
       return { [key]: value };
     } else if (zodType instanceof z.ZodSet) {
-      return [this.zodTypeToReqDefault(zodType._def.valueType, name)];
+      return [this.zodTypeToReqDefault((zodType as z.ZodSet<z.ZodType>).def.valueType, name)];
     } else if (zodType instanceof z.ZodIntersection) {
-      return this.zodTypeToReqDefault(zodType._def.right, name);
+      return this.zodTypeToReqDefault((zodType as z.ZodIntersection<z.ZodType, z.ZodType>).def.right, name);
+    } else if (zodType instanceof z.ZodDefault) {
+      return this.zodTypeToReqDefault((zodType as z.ZodDefault<z.ZodType>).def.innerType, name);
     } else {
       // console.log(zodType);
-      return `unknown-${zodType._type}`;
+      return `unknown-${zodType.type}`;
     }
   }
 

package/src/templates/generated_sso.template.ts

@@ -1,4 +1,8 @@
-import { SubsetQuery, TemplateOptions } from "../types/types";
+import {
+  isManyToManyRelationProp,
+  SubsetQuery,
+  TemplateOptions,
+} from "../types/types";
 import { EntityManager } from "../entity/entity-manager";
 import { Template } from "./base-template";
 import inflection from "inflection";
@@ -6,6 +10,7 @@ import { SourceCode } from "./generated.template";
 import _ from "lodash";
 import { nonNullable } from "../utils/utils";
 import { Sonamu } from "../api";
+import { Entity } from "../entity/entity";
 
 export class Template__generated_sso extends Template {
   constructor() {
@@ -62,6 +67,12 @@ export class Template__generated_sso extends Template {
       })
       .filter(nonNullable);
 
+    // DatabaseSchema 생성
+    const dbSchemaSourceCode = this.getDatabaseSchemaSourceCode(entities);
+    if (dbSchemaSourceCode) {
+      sourceCodes.push(dbSchemaSourceCode);
+    }
+
     const sourceCode = sourceCodes.reduce(
       (result, ts) => {
         if (ts === null) {
@@ -82,7 +93,44 @@ export class Template__generated_sso extends Template {
       ...this.getTargetAndPath(),
       body: sourceCode.lines.join("\n"),
       importKeys: sourceCode.importKeys,
-      customHeaders: [`import { SubsetQuery } from "sonamu";`],
+      customHeaders: [
+        `import { SubsetQuery, ManyToManyBaseSchema } from "sonamu";`,
+      ],
+    };
+  }
+
+  getDatabaseSchemaSourceCode(entities: Entity[]): SourceCode | null {
+    if (entities.length === 0) {
+      return null;
+    }
+
+    const entitySchemaLines = entities.map(
+      (entity) => `${entity.table}: ${entity.id}BaseSchema;`
+    );
+
+    const joinTableSchemaLines = _.uniq(
+      entities.flatMap((entity) =>
+        entity.props.filter(isManyToManyRelationProp).map((prop) => {
+          const fromTableKey = inflection.singularize(entity.table);
+          const toTableKey = inflection.singularize(
+            EntityManager.get(prop.with).table
+          );
+          return `${prop.joinTable}: ManyToManyBaseSchema<"${fromTableKey}", "${toTableKey}">;`;
+        })
+      )
+    );
+
+    return {
+      label: `DatabaseSchema`,
+      lines: [
+        `declare module "sonamu" {`,
+        `  export interface DatabaseSchemaExtend {`,
+        ...entitySchemaLines,
+        ...joinTableSchemaLines,
+        `  }`,
+        `}`,
+      ],
+      importKeys: entities.map((entity) => `${entity.id}BaseSchema`),
     };
   }
 }

package/src/templates/model.template.ts

@@ -3,7 +3,6 @@ import { EntityManager, EntityNamesRecord } from "../entity/entity-manager";
 import { Template } from "./base-template";
 import { Template__view_list } from "./view_list.template";
 import { Sonamu } from "../api";
-import { DB } from "../database/db";
 
 export class Template__model extends Template {
   constructor() {
@@ -25,6 +24,7 @@ export class Template__model extends Template {
     listParamsNode: RenderingNode
   ) {
     const names = EntityManager.getNamesFromId(entityId);
+    const entity = EntityManager.get(entityId);
 
     const vlTpl = new Template__view_list();
     if (listParamsNode?.children === undefined) {
@@ -34,7 +34,143 @@ export class Template__model extends Template {
 
     return {
       ...this.getTargetAndPath(names),
-      body: DB.generator.generateModelTemplate(entityId, def),
+      body: `
+import { BaseModelClass, ListResult, asArray, NotFoundException, BadRequestException, api } from 'sonamu';
+import {
+  ${entityId}SubsetKey,
+  ${entityId}SubsetMapping,
+} from "../sonamu.generated";
+import {
+  ${names.camel}SubsetQueries,
+} from "../sonamu.generated.sso";
+import { ${entityId}ListParams, ${entityId}SaveParams } from "./${names.fs}.types";
+
+/*
+  ${entityId} Model
+*/
+class ${entityId}ModelClass extends BaseModelClass {
+  modelName = "${entityId}";
+
+  @api({ httpMethod: "GET", clients: ["axios", "swr"], resourceName: "${entityId}" })
+  async findById<T extends ${entityId}SubsetKey>(
+    subset: T,
+    id: number
+  ): Promise<${entityId}SubsetMapping[T]> {
+    const { rows } = await this.findMany(subset, {
+      id,
+      num: 1,
+      page: 1,
+    });
+    if (!rows[0]) {
+      throw new NotFoundException(\`존재하지 않는 ${names.capital} ID \${id}\`);
+    }
+
+    return rows[0];
+  }
+
+  async findOne<T extends ${entityId}SubsetKey>(
+    subset: T,
+    listParams: ${entityId}ListParams
+  ): Promise<${entityId}SubsetMapping[T] | null> {
+    const { rows } = await this.findMany(subset, {
+      ...listParams,
+      num: 1,
+      page: 1,
+    });
+
+    return rows[0] ?? null;
+  }
+
+  @api({ httpMethod: "GET", clients: ["axios", "swr"], resourceName: "${names.capitalPlural}" })
+  async findMany<T extends ${entityId}SubsetKey>(
+    subset: T,
+    params: ${entityId}ListParams = {}
+  ): Promise<ListResult<${entityId}SubsetMapping[T]>> {
+    // params with defaults
+    params = {
+      num: 24,
+      page: 1,
+      search: "${def.search}",
+      orderBy: "${def.orderBy}",
+      ...params,
+    };
+
+    // build queries
+    let { rows, total } = await this.runSubsetQuery({
+      subset,
+      params,
+      subsetQuery: ${names.camel}SubsetQueries[subset],
+      build: ({ qb }) => {
+        // id
+        if (params.id) {
+          qb.whereIn("${entity.table}.id", asArray(params.id));
+        }
+
+        // search-keyword
+        if (params.search && params.keyword && params.keyword.length > 0) {
+          if (params.search === "id") {
+            qb.where("${entity.table}.id", params.keyword);
+          // } else if (params.search === "field") {
+          //   qb.where("${entity.table}.field", "like", \`%\${params.keyword}%\`);
+          } else {
+            throw new BadRequestException(
+              \`구현되지 않은 검색 필드 \${params.search}\`
+            );
+          }
+        }
+
+        // orderBy
+        if (params.orderBy) {
+          // default orderBy
+          const [orderByField, orderByDirec] = params.orderBy.split("-");
+          qb.orderBy("${entity.table}." + orderByField, orderByDirec);
+        }
+
+        return qb;
+      },
+      debug: false,
+    });
+
+    return {
+      rows,
+      total,
+    };
+  }
+
+  @api({ httpMethod: "POST" })
+  async save(
+    spa: ${entityId}SaveParams[]
+  ): Promise<number[]> {
+    const wdb = this.getPuri("w");
+
+    // register
+    spa.map((sp) => {
+      wdb.ubRegister("${entity.table}", sp);
+    });
+
+    // transaction
+    return wdb.transaction(async (trx) => {
+      const ids = await trx.ubUpsert("${entity.table}");
+
+      return ids;
+    });
+  }
+
+  @api({ httpMethod: "POST", guards: [ "admin" ] })
+  async del(ids: number[]): Promise<number> {
+    const wdb = this.getPuri("w");
+
+    // transaction
+    await wdb.transaction(async (trx) => {
+      return trx.table("${entity.table}").whereIn("${entity.table}.id", ids).delete();
+    });
+
+    return ids.length;
+  }
+}
+
+export const ${entityId}Model = new ${entityId}ModelClass();
+      `.trim(),
       importKeys: [],
     };
   }

package/src/templates/service.template.ts

@@ -73,7 +73,6 @@ export class Template__service extends Template {
               (param) =>
                 !ApiParamType.isContext(param.type) &&
                 !ApiParamType.isRefKnex(param.type) &&
-                !ApiParamType.isRefKysely(param.type) &&
                 !(param.optional === true && param.name.startsWith("_")) // _로 시작하는 파라미터는 제외
             );
 

package/src/templates/view_form.template.ts

@@ -81,6 +81,8 @@ export class Template__view_form extends Template {
         } else {
           return `<TextArea rows={8} placeholder="${col.label}" ${regExpr} />`;
         }
+      case "datetime":
+        return `<Input type="datetime-local" ${regExpr} />`;
       case "string-datetime":
         return `<SQLDateTimeInput ${regExpr} />`;
       case "string-date":
@@ -147,9 +149,11 @@ export class Template__view_form extends Template {
         } else if (col.zodType instanceof z.ZodNumber) {
           value = 0;
         } else if (col.zodType instanceof z.ZodEnum) {
-          value = Object.keys(col.zodType.Enum)[0];
+          value = Object.keys(col.zodType.options)[0];
         } else if (col.zodType instanceof z.ZodBoolean) {
           value = false;
+        } else if (col.zodType instanceof z.ZodDate) {
+          value = new Date();
         } else if (col.zodType instanceof z.ZodString) {
           if (col.renderType === "string-datetime") {
             value = "now()";
@@ -268,10 +272,10 @@ import {
 } from 'semantic-ui-react';
 import { DateTime } from "luxon";
 
-import { BackLink, LinkInput, NumberInput, BooleanToggle, SQLDateTimeInput, SQLDateInput, useTypeForm, useGoBack } from "@sonamu-kit/react-sui";
+import { BackLink, LinkInput, NumberInput, BooleanToggle, SQLDateTimeInput, SQLDateInput, useTypeForm, useGoBack, formatDateTime } from "@sonamu-kit/react-sui";
 import { defaultCatch } from 'src/services/sonamu.shared';
-import { ImageUploader } from 'src/admin-common/ImageUploader';
-import { useCommonModal } from "src/admin-common/CommonModal";
+// import { ImageUploader } from 'src/admin-common/ImageUploader';
+// import { useCommonModal } from "src/admin-common/CommonModal";
 
 import { ${names.capital}SaveParams } from 'src/services/${names.fs}/${
         names.fs
@@ -343,14 +347,14 @@ export function ${names.capitalPlural}Form({ id, mode }: ${
   }, [id]);
 
   // CommonModal
-  const { doneModal, closeModal } = useCommonModal();
+  // const { doneModal, closeModal } = useCommonModal();
 
   // 저장
   const { goBack } = useGoBack();
   const handleSubmit = useCallback(() => {
     ${names.capital}Service.save([form]).then(([id]) => {
       if( mode === 'modal' ) {
-        doneModal();
+        // doneModal();
       } else {
         goBack('/admin/${names.fsPlural}');
       }
@@ -383,7 +387,7 @@ export function ${names.capitalPlural}Form({ id, mode }: ${
               .map((col) => {
                 if (col.name === "created_at") {
                   return `{form.id && (${this.wrapFG(
-                    `<div className="p-8px">{form.${col.name}}</div>`,
+                    `<div className="p-8px">{formatDateTime(form.${col.name})}</div>`,
                     "등록일시"
                   )})}`;
                 } else {

package/src/templates/view_list.template.ts

@@ -54,6 +54,12 @@ export class Template__view_list extends Template {
         return `<>{${
           col.nullable ? `${colName} && ` : ""
         }<img src={${colName}} />}</>`;
+      case "datetime":
+        if (col.nullable) {
+          return `<span className="text-tiny">{${colName} === null ? '-' : formatDateTime(${colName})}</span>`;
+        } else {
+          return `<span className="text-tiny">{formatDateTime(${colName})}</span>`;
+        }
       case "string-datetime":
         if (col.nullable) {
           return `<span className="text-tiny">{${colName} === null ? '-' : dateF(${colName})}</span>`;
@@ -133,7 +139,9 @@ export class Template__view_list extends Template {
       return `import { ${names.capital}SearchInput } from "src/components/${names.fs}/${names.capital}SearchInput";`;
     } else if (col.renderType === "enums") {
       if (col.name === "orderBy") {
-        const componentId = `${names.capital}${inflection.camelize(col.name)}Select`;
+        const componentId = `${names.capital}${inflection.camelize(
+          col.name
+        )}Select`;
         return `import { ${componentId} } from "src/components/${names.fs}/${componentId}";`;
       } else {
         try {
@@ -217,11 +225,11 @@ export class Template__view_list extends Template {
       (col) => col.name === "orderBy"
     )?.zodType;
     if (orderByZodType && orderByZodType instanceof z.ZodEnum) {
-      def.orderBy = Object.keys(orderByZodType.Enum)[0];
+      def.orderBy = orderByZodType.options[0].toString();
     }
     const searchZodType = columns.find((col) => col.name === "search")?.zodType;
     if (searchZodType && searchZodType instanceof z.ZodEnum) {
-      def.search = Object.keys(searchZodType.Enum)[0];
+      def.search = searchZodType.options[0].toString();
     }
     return def;
   }
@@ -347,7 +355,7 @@ import {
 } from 'semantic-ui-react';
 import classNames from 'classnames';
 import { DateTime } from "luxon";
-import { DelButton, EditButton, AppBreadcrumbs, AddButton, useSelection, useListParams, SonamuCol, numF, dateF, datetimeF } from '@sonamu-kit/react-sui';
+import { DelButton, EditButton, AppBreadcrumbs, AddButton, useSelection, useListParams, SonamuCol, numF, formatDate, formatDateTime } from '@sonamu-kit/react-sui';
 
 import { ${names.capital}SubsetA } from "src/services/sonamu.generated";
 import { ${names.capital}Service } from 'src/services/${names.fs}/${