sonamu 0.0.1

package/src/templates/model_test.template.ts

@@ -0,0 +1,39 @@
+import { TemplateOptions } from "../types/types";
+import { SMDManager, SMDNamesRecord } from "../smd/smd-manager";
+import { Template } from "./base-template";
+
+export class Template__model_test extends Template {
+  constructor() {
+    super("model_test");
+  }
+
+  getTargetAndPath(names: SMDNamesRecord) {
+    return {
+      target: "api/src/application",
+      path: `${names.fs}/${names.fs}.model.test.ts`,
+    };
+  }
+
+  render({ smdId }: TemplateOptions["model_test"]) {
+    const names = SMDManager.getNamesFromId(smdId);
+
+    return {
+      ...this.getTargetAndPath(names),
+      body: `
+import { BadRequestException, FixtureManager } from "@sonamu/core";
+import { ${smdId}ListParams, ${smdId}SaveParams } from "../${names.fs}/${names.fs}.types";
+import { ${smdId}Model } from "../${names.fs}/${names.fs}.model";
+
+describe.skip("${smdId}Model Model", () => {
+  new FixtureManager([
+  ]);
+
+  test("Query", async () => {
+  });
+});
+
+      `.trim(),
+      importKeys: [],
+    };
+  }
+}

package/src/templates/service.template.ts

@@ -0,0 +1,263 @@
+import { camelize } from "inflection";
+import { groupBy, sortBy, difference, uniq } from "lodash";
+import { TemplateOptions } from "../types/types";
+import { SMDManager, SMDNamesRecord } from "../smd/smd-manager";
+import { ApiParamType, ApiParam } from "../types/types";
+import {
+  apiParamTypeToTsType,
+  apiParamToTsCode,
+  unwrapPromiseOnce,
+} from "../api/code-converters";
+import { ExtendedApi } from "../api/decorators";
+import { Template } from "./base-template";
+
+export class Template__service extends Template {
+  constructor() {
+    super("service");
+  }
+
+  getTargetAndPath(names: SMDNamesRecord) {
+    return {
+      target: ":target/src/services",
+      path: `${names.fs}/${names.fs}.service.ts`,
+    };
+  }
+
+  render({ smdId }: TemplateOptions["service"], apis: ExtendedApi[]) {
+    const names = SMDManager.getNamesFromId(smdId);
+
+    // 서비스 TypeSource
+    const { lines, importKeys } = this.getTypeSource(apis);
+
+    return {
+      ...this.getTargetAndPath(names),
+      body: lines.join("\n"),
+      importKeys: importKeys.filter(
+        (key) => ["ListResult"].includes(key) === false
+      ),
+      customHeaders: [
+        `import { z } from 'zod';`,
+        `import qs from "qs";`,
+        `import useSWR, { SWRResponse } from "swr";`,
+        `import { fetch, ListResult, SWRError, SwrOptions, handleConditional } from '../sonamu.shared';`,
+      ],
+    };
+  }
+
+  getTypeSource(
+    apis: ExtendedApi[],
+    apiPrefix: string = "/api"
+  ): { lines: string[]; importKeys: string[] } {
+    const importKeys: string[] = [];
+
+    // 제네릭에서 선언한 타입, importKeys에서 제외 필요
+    let typeParamNames: string[] = [];
+
+    const groups = groupBy(apis, (api) => api.modelName);
+    const body = Object.keys(groups)
+      .map((modelName) => {
+        const methods = groups[modelName];
+        const methodCodes = methods
+          .map((api) => {
+            // 컨텍스트 제외된 파라미터 리스트
+            const paramsWithoutContext = api.parameters.filter(
+              (param) => !ApiParamType.isContext(param.type)
+            );
+
+            // 파라미터 타입 정의
+            const typeParamsDef = api.typeParameters
+              .map((typeParam) => {
+                return apiParamTypeToTsType(typeParam, importKeys);
+              })
+              .join(", ");
+            typeParamNames = typeParamNames.concat(
+              api.typeParameters.map((typeParam) => typeParam.id)
+            );
+
+            // 파라미터 정의
+            const paramsDef = apiParamToTsCode(
+              paramsWithoutContext,
+              importKeys
+            );
+
+            // 리턴 타입 정의
+            const returnTypeDef = apiParamTypeToTsType(
+              unwrapPromiseOnce(api.returnType),
+              importKeys
+            );
+
+            // 페이로드 데이터 정의
+            const payloadDef = `{ ${paramsWithoutContext
+              .map((param) => param.name)
+              .join(", ")} }`;
+
+            return sortBy(api.options.clients, (client) =>
+              client === "swr" ? 0 : 1
+            )
+              .map((client) => {
+                const apiBaseUrl = `${apiPrefix}${api.path}`;
+                switch (client) {
+                  case "axios":
+                    return this.renderAxios(
+                      api,
+                      apiBaseUrl,
+                      typeParamsDef,
+                      paramsDef,
+                      returnTypeDef,
+                      payloadDef
+                    );
+                  case "axios-multipart":
+                    return this.renderAxiosMultipart(
+                      api,
+                      apiBaseUrl,
+                      typeParamsDef,
+                      paramsDef,
+                      returnTypeDef,
+                      paramsWithoutContext
+                    );
+                  case "swr":
+                    return this.renderSwr(
+                      api,
+                      apiBaseUrl,
+                      typeParamsDef,
+                      paramsDef,
+                      returnTypeDef,
+                      payloadDef
+                    );
+                  case "window-fetch":
+                    return this.renderWindowFetch(
+                      api,
+                      apiBaseUrl,
+                      typeParamsDef,
+                      paramsDef,
+                      payloadDef
+                    );
+                  case "socketio":
+                  default:
+                    return `// Not supported ${camelize(client, true)} yet.`;
+                }
+              })
+              .join("\n");
+          })
+          .join("\n\n");
+
+        return `export namespace ${modelName.replace("Model", "Service")} {
+${methodCodes}
+}`;
+      })
+      .join("\n\n");
+    return {
+      lines: [body],
+      importKeys: difference(uniq(importKeys), typeParamNames),
+    };
+  }
+
+  renderAxios(
+    api: ExtendedApi,
+    apiBaseUrl: string,
+    typeParamsDef: string,
+    paramsDef: string,
+    returnTypeDef: string,
+    payloadDef: string
+  ) {
+    const methodNameAxios = api.options.resourceName
+      ? "get" + camelize(api.options.resourceName)
+      : api.methodName;
+
+    if (api.options.httpMethod === "GET") {
+      return `
+export async function ${methodNameAxios}${typeParamsDef}(${paramsDef}): Promise<${returnTypeDef}> {
+    return fetch({
+      method: "GET",
+      url: \`${apiBaseUrl}?\${qs.stringify(${payloadDef})}\`,
+    });
+}
+    `.trim();
+    } else {
+      return `
+export async function ${methodNameAxios}${typeParamsDef}(${paramsDef}): Promise<${returnTypeDef}> {
+    return fetch({
+      method: '${api.options.httpMethod}',
+      url: \`${apiBaseUrl}\`,
+      data: ${payloadDef},
+    });
+}
+      `.trim();
+    }
+  }
+
+  renderAxiosMultipart(
+    api: ExtendedApi,
+    apiBaseUrl: string,
+    typeParamsDef: string,
+    paramsDef: string,
+    returnTypeDef: string,
+    paramsWithoutContext: ApiParam[]
+  ) {
+    const formDataDef = [
+      'formData.append("file", file);',
+      ...paramsWithoutContext.map(
+        (param) => `formData.append('${param.name}', ${param.name});`
+      ),
+    ].join("\n");
+
+    const paramsDefComma = paramsDef !== "" ? ", " : "";
+    return `
+export async function ${api.methodName}${typeParamsDef}(
+  ${paramsDef}${paramsDefComma}
+  file: File,
+  onUploadProgress?: (pe:ProgressEvent) => void
+  ): Promise<${returnTypeDef}> {
+    const formData = new FormData();
+    ${formDataDef}
+    return fetch({
+      method: 'POST',
+      url: \`${apiBaseUrl}\`,
+      headers: {
+        "Content-Type": "multipart/form-data",
+      },
+      onUploadProgress,
+      data: formData,
+    });
+  }
+  `.trim();
+  }
+
+  renderSwr(
+    api: ExtendedApi,
+    apiBaseUrl: string,
+    typeParamsDef: string,
+    paramsDef: string,
+    returnTypeDef: string,
+    payloadDef: string
+  ) {
+    const methodNameSwr = api.options.resourceName
+      ? "use" + camelize(api.options.resourceName)
+      : "use" + camelize(api.methodName);
+    return `  export function ${camelize(
+      methodNameSwr,
+      true
+    )}${typeParamsDef}(${[paramsDef, "options?: SwrOptions"]
+      .filter((p) => p !== "")
+      .join(",")}, ): SWRResponse<${returnTypeDef}, SWRError> {
+    return useSWR<${returnTypeDef}, SWRError>(handleConditional([
+      \`${apiBaseUrl}\`,
+      qs.stringify(${payloadDef}),
+    ], options?.conditional));
+  }`;
+  }
+
+  renderWindowFetch(
+    api: ExtendedApi,
+    apiBaseUrl: string,
+    typeParamsDef: string,
+    paramsDef: string,
+    payloadDef: string
+  ) {
+    return `
+export async function ${api.methodName}${typeParamsDef}(${paramsDef}): Promise<Response> {
+    return window.fetch(\`${apiBaseUrl}?\${qs.stringify(${payloadDef})}\`);
+}
+    `.trim();
+  }
+}

package/src/templates/smd.template.ts

@@ -0,0 +1,49 @@
+import { TemplateOptions } from "../types/types";
+import { SMDManager, SMDNamesRecord } from "../smd/smd-manager";
+import { Template } from "./base-template";
+
+export class Template__smd extends Template {
+  constructor() {
+    super("smd");
+  }
+
+  getTargetAndPath(names: SMDNamesRecord) {
+    return {
+      target: "api/src/application",
+      path: `${names.fs}/${names.fs}.smd.ts`,
+    };
+  }
+
+  render(options: TemplateOptions["smd"]) {
+    const { smdId, title, refCode } = options;
+    const names = SMDManager.getNamesFromId(smdId);
+
+    return {
+      ...this.getTargetAndPath(names),
+      body: `
+import { p, MDInput } from "@sonamu/core";
+import { ${smdId}FieldExpr } from "./${names.fs}.generated";
+
+/*
+  ${smdId} SMD
+*/
+
+export const ${names.camel}MdInput: SMDInput<${smdId}FieldExpr> = {
+  id: "${smdId}",
+  title: "${title ?? smdId}",
+  props: [
+    p.integer("id", { unsigned: true }),
+    p.timestamp("created_at", {
+      now: true,
+    }),
+  ],
+  subsets: {
+    A: [ 'id', 'created_at' ]
+  }
+};
+${refCode ? `\n/* REFERENCE\n\n${refCode}\n*/` : ""}
+`.trim(),
+      importKeys: [],
+    };
+  }
+}

package/src/templates/view_enums_buttonset.template.ts

@@ -0,0 +1,34 @@
+import { TemplateOptions } from "../types/types";
+import { SMDManager, SMDNamesRecord } from "../smd/smd-manager";
+import { Template } from "./base-template";
+
+export class Template__view_enums_buttonset extends Template {
+  constructor() {
+    super("view_enums_buttonset");
+  }
+
+  getTargetAndPath(names: SMDNamesRecord, componentId: string) {
+    return {
+      target: "web/src/components",
+      path: `${names.fs}/${componentId}ButtonSet.tsx`,
+    };
+  }
+
+  render({ smdId, enumId }: TemplateOptions["view_enums_buttonset"]) {
+    const names = SMDManager.getNamesFromId(smdId);
+
+    return {
+      ...this.getTargetAndPath(names, enumId),
+      body: `
+/*
+view_enums_buttonset
+${JSON.stringify({
+  key: this.key,
+  options: smdId,
+})}
+*/
+      `.trim(),
+      importKeys: [],
+    };
+  }
+}

package/src/templates/view_enums_dropdown.template.ts

@@ -0,0 +1,67 @@
+import { TemplateOptions } from "../types/types";
+import { SMDManager, SMDNamesRecord } from "../smd/smd-manager";
+import { Template } from "./base-template";
+
+export class Template__view_enums_dropdown extends Template {
+  constructor() {
+    super("view_enums_dropdown");
+  }
+
+  getTargetAndPath(names: SMDNamesRecord, enumId: string) {
+    return {
+      target: "web/src/components",
+      path: `${names.fs}/${enumId}Dropdown.tsx`,
+    };
+  }
+
+  render({
+    smdId,
+    enumId,
+    idConstant,
+  }: TemplateOptions["view_enums_dropdown"]) {
+    const names = SMDManager.getNamesFromId(smdId);
+    const label = getLabel(idConstant);
+
+    return {
+      ...this.getTargetAndPath(names, enumId),
+      body: `
+import React from 'react';
+import {
+  Dropdown,
+  DropdownProps,
+} from 'semantic-ui-react';
+
+import { ${names.constant} } from 'src/services/${names.fs}/${names.fs}.enums';
+
+export function ${enumId}Dropdown(props: DropdownProps) {
+  const options = Object.entries(${names.constant}.${idConstant}).map(([key, { ko }]) => {
+    return {
+      key,
+      value: key,
+      text: "${label}: " + ko,
+    };
+  });
+  return (
+    <Dropdown
+      className="label"
+      options={options}
+      {...props}
+    />
+  );
+}
+      `.trim(),
+      importKeys: [],
+    };
+  }
+}
+
+export function getLabel(idConstant: string): string {
+  switch (idConstant) {
+    case "ORDER_BY":
+      return "정렬";
+    case "SEARCH_FIELD":
+      return "검색";
+    default:
+      return idConstant;
+  }
+}

package/src/templates/view_enums_select.template.ts

@@ -0,0 +1,60 @@
+import { TemplateOptions } from "../types/types";
+import { SMDManager, SMDNamesRecord } from "../smd/smd-manager";
+import { Template } from "./base-template";
+import { getLabel } from "./view_enums_dropdown.template";
+
+export class Template__view_enums_select extends Template {
+  constructor() {
+    super("view_enums_select");
+  }
+
+  getTargetAndPath(names: SMDNamesRecord, enumId: string) {
+    return {
+      target: "web/src/components",
+      path: `${names.fs}/${enumId}Select.tsx`,
+    };
+  }
+
+  render({ smdId, enumId, idConstant }: TemplateOptions["view_enums_select"]) {
+    const names = SMDManager.getNamesFromId(smdId);
+    const label = getLabel(idConstant);
+
+    return {
+      ...this.getTargetAndPath(names, enumId),
+      body: `
+import React from 'react';
+import {
+  Dropdown,
+  DropdownProps,
+} from 'semantic-ui-react';
+
+import { ${names.constant} } from 'src/services/${names.fs}/${names.fs}.enums';
+
+export type ${enumId}SelectProps = {
+  placeholder?: string;
+  textPrefix?: string;
+} & DropdownProps;
+export function ${enumId}Select({placeholder, textPrefix, ...props}: ${enumId}SelectProps) {
+  const typeOptions = Object.entries(${names.constant}.${idConstant}).map(([key, { ko }]) => {
+    return {
+      key,
+      value: key,
+      text: (textPrefix ?? '${label}: ') + ko,
+    };
+  });
+
+  return (
+    <Dropdown
+      placeholder={placeholder ?? "${label}"}
+      selection
+      options={typeOptions}
+      selectOnBlur={false}
+      {...props}
+    />
+  );
+}
+      `.trim(),
+      importKeys: [],
+    };
+  }
+}