sonamu 0.0.1

package/src/templates/base-template.ts

@@ -0,0 +1,19 @@
+import { TemplateKey, TemplateOptions } from "../types/types";
+import { SMDNamesRecord } from "../smd/smd-manager";
+import { RenderedTemplate } from "../syncer/syncer";
+
+export abstract class Template {
+  constructor(public key: TemplateKey) {}
+  public abstract render(
+    options: TemplateOptions[TemplateKey],
+    ...extra: unknown[]
+  ): RenderedTemplate;
+
+  public abstract getTargetAndPath(
+    names: SMDNamesRecord,
+    ...extra: unknown[]
+  ): {
+    target: string;
+    path: string;
+  };
+}

package/src/templates/generated.template.ts

@@ -0,0 +1,247 @@
+import { camelize } from "inflection";
+import { uniq } from "lodash";
+import {
+  isDateProp,
+  isDateTimeProp,
+  isTimestampProp,
+  TemplateOptions,
+} from "../types/types";
+import { SMDManager, SMDNamesRecord } from "../smd/smd-manager";
+import { SMD } from "../smd/smd";
+import { SMDPropNode, SubsetQuery } from "../types/types";
+import { propNodeToZodTypeDef } from "../api/code-converters";
+import { Template } from "./base-template";
+
+export class Template__generated extends Template {
+  constructor() {
+    super("generated");
+  }
+
+  getTargetAndPath(names: SMDNamesRecord) {
+    return {
+      target: "api/src/application",
+      path: `${names.fs}/${names.fs}.generated.ts`,
+    };
+  }
+
+  render({ smdId }: TemplateOptions["generated"]) {
+    const names = SMDManager.getNamesFromId(smdId);
+    const smd = SMDManager.get(smdId);
+
+    const typeSource = [
+      this.getBaseSchemaTypeSource(smd),
+      this.getBaseListParamsTypeSource(smd),
+      this.getSubsetTypeSource(smd),
+    ].reduce(
+      (result, ts) => {
+        if (ts === null) {
+          return result;
+        }
+        return {
+          lines: [...result!.lines, ...ts.lines],
+          importKeys: uniq([...result!.importKeys, ...ts.importKeys]),
+        };
+      },
+      {
+        lines: [],
+        importKeys: [],
+      }
+    );
+
+    const fieldExprs = smd
+      .getFieldExprs()
+      .map((fieldExpr) => `"${fieldExpr}"`)
+      .join(" | ");
+    const fieldExprsLine = `export type ${smd.id}FieldExpr = ${
+      fieldExprs.length > 0 ? fieldExprs : "string"
+    }`;
+
+    return {
+      ...this.getTargetAndPath(names),
+      body: [...typeSource!.lines, fieldExprsLine, "/* END Server-side Only */"]
+        .join("\n")
+        .trim(),
+      importKeys: typeSource?.importKeys ?? [],
+      customHeaders: [
+        `import { z } from 'zod';`,
+        smd.props.length > 0
+          ? `import { zArrayable${
+              smd.props.find(
+                (p) => isTimestampProp(p) || isDateProp(p) || isDateTimeProp(p)
+              )
+                ? ", SQLDateTimeString"
+                : ""
+            } } from "@sonamu/core";`
+          : "",
+      ],
+    };
+  }
+
+  getBaseSchemaTypeSource(
+    smd: SMD,
+    depth: number = 0,
+    importKeys: string[] = []
+  ): {
+    lines: string[];
+    importKeys: string[];
+  } {
+    const childrenIds = SMDManager.getChildrenIds(smd.id);
+
+    const schemaName = `${smd.names.module}BaseSchema`;
+    const propNode: SMDPropNode = {
+      nodeType: "object",
+      children: smd.props.map((prop) => {
+        return {
+          nodeType: "plain",
+          prop,
+        };
+      }),
+    };
+
+    const schemaBody = propNodeToZodTypeDef(propNode, importKeys);
+
+    const lines = [
+      `export const ${schemaName} = ${schemaBody}`,
+      `export type ${schemaName} = z.infer<typeof ${schemaName}>`,
+      ...childrenIds
+        .map((childId) => {
+          const child = SMDManager.get(childId);
+          const { lines } = this.getBaseSchemaTypeSource(
+            child,
+            depth + 1,
+            importKeys
+          );
+          return lines;
+        })
+        .flat(),
+    ];
+
+    return {
+      importKeys,
+      lines,
+    };
+  }
+
+  getBaseListParamsTypeSource(smd: SMD): {
+    lines: string[];
+    importKeys: string[];
+  } {
+    // Prop 없는 MD인 경우 생성 제외
+    if (smd.props.length === 0) {
+      return {
+        lines: [],
+        importKeys: [],
+      };
+    }
+
+    const schemaName = `${smd.names.module}BaseListParams`;
+
+    const filterProps = smd.props.filter((prop) => prop.toFilter === true);
+
+    const propNodes: SMDPropNode[] = filterProps.map((prop) => {
+      return {
+        nodeType: "plain" as const,
+        prop,
+        children: [],
+      };
+    });
+
+    const importKeys: string[] = [`${smd.id}SearchField`, `${smd.id}OrderBy`];
+    const filterBody = propNodes
+      .map((propNode) => propNodeToZodTypeDef(propNode, importKeys))
+      .join("\n");
+
+    const schemaBody = `
+z.object({
+  num: z.number().int().nonnegative(),
+  page: z.number().int().min(1),
+  search: ${smd.id}SearchField,
+  keyword: z.string(),
+  orderBy: ${smd.id}OrderBy,
+  withoutCount: z.boolean(),
+  id: zArrayable(z.number().int().positive()),${filterBody}
+}).partial();
+`.trim();
+
+    const lines = [
+      `export const ${schemaName} = ${schemaBody}`,
+      `export type ${schemaName} = z.infer<typeof ${schemaName}>`,
+    ];
+
+    return {
+      importKeys,
+      lines,
+    };
+  }
+
+  getSubsetTypeSource(smd: SMD): {
+    lines: string[];
+    importKeys: string[];
+  } | null {
+    if (Object.keys(smd.subsets).length == 0) {
+      return null;
+    }
+
+    const subsetKeys = Object.keys(smd.subsets);
+
+    const subsetQueryObject = subsetKeys.reduce(
+      (r, subsetKey) => {
+        const subsetQuery = smd.getSubsetQuery(subsetKey);
+        r[subsetKey] = subsetQuery;
+        return r;
+      },
+      {} as {
+        [key: string]: SubsetQuery;
+      }
+    );
+
+    const importKeys: string[] = [];
+    const lines: string[] = [
+      "",
+      ...subsetKeys
+        .map((subsetKey) => {
+          // 서브셋에서 FieldExpr[] 가져옴
+          const fieldExprs = smd.subsets[subsetKey];
+
+          // FieldExpr[]로 MDPropNode[] 가져옴
+          const propNodes = smd.fieldExprsToPropNodes(fieldExprs);
+          const schemaName = `${smd.names.module}Subset${subsetKey}`;
+          const propNode: SMDPropNode = {
+            nodeType: "object",
+            children: propNodes,
+          };
+
+          // MDPropNode[]로 ZodTypeDef(string)을 가져옴
+          const body = propNodeToZodTypeDef(propNode, importKeys);
+
+          return [
+            `export const ${schemaName} = ${body}`,
+            `export type ${schemaName} = z.infer<typeof ${schemaName}>`,
+            "",
+          ];
+        })
+        .flat(),
+      "",
+      `export type ${smd.names.module}SubsetMapping = {`,
+      ...subsetKeys.map(
+        (subsetKey) => `  ${subsetKey}: ${smd.names.module}Subset${subsetKey};`
+      ),
+      "}",
+      `export const ${smd.names.module}SubsetKey = z.enum([${subsetKeys
+        .map((k) => `"${k}"`)
+        .join(",")}]);`,
+      `export type ${smd.names.module}SubsetKey = z.infer<typeof ${smd.names.module}SubsetKey>`,
+      "",
+      "/* BEGIN- Server-side Only */",
+      `import { SubsetQuery } from "@sonamu/core";`,
+      `export const ${camelize(smd.id, true)}SubsetQueries:{ [key in ${
+        smd.names.module
+      }SubsetKey]: SubsetQuery} = ${JSON.stringify(subsetQueryObject)}`,
+      "",
+    ];
+    return {
+      lines,
+      importKeys: uniq(importKeys),
+    };
+  }
+}

package/src/templates/generated_http.template.ts

@@ -0,0 +1,114 @@
+import qs from "qs";
+import { z } from "zod";
+import { TemplateOptions } from "../types/types";
+import { SMDManager, SMDNamesRecord } from "../smd/smd-manager";
+import { getZodObjectFromApi } from "../api/code-converters";
+import { ExtendedApi } from "../api/decorators";
+import { Template } from "./base-template";
+import prettier from "prettier";
+import { DateTime } from "luxon";
+import { Syncer } from "../syncer/syncer";
+
+export class Template__generated_http extends Template {
+  constructor() {
+    super("generated_http");
+  }
+
+  getTargetAndPath(names: SMDNamesRecord) {
+    return {
+      target: "api/src/application",
+      path: `${names.fs}/${names.fs}.generated.http`,
+    };
+  }
+
+  render({ smdId }: TemplateOptions["generated"], apis: ExtendedApi[]) {
+    const names = SMDManager.getNamesFromId(smdId);
+    const references = Syncer.getInstance().types;
+
+    const lines = apis.map((api) => {
+      const reqObject = this.resolveApiParams(api, references);
+
+      let qsLines: string[] = [];
+      let bodyLines: string[] = [];
+      if ((api.options.httpMethod ?? "GET") === "GET") {
+        qsLines = [
+          qs.stringify(reqObject, { encode: false }).split("&").join("\n\t&"),
+        ];
+      } else {
+        bodyLines = [
+          "",
+          prettier.format(JSON.stringify(reqObject), {
+            parser: "json",
+          }),
+        ];
+      }
+      return [
+        [
+          `${api.options.httpMethod ?? "GET"} {{baseUrl}}/api${api.path}`,
+          ...qsLines,
+        ].join("\n\t?"),
+        `Content-Type: ${api.options.contentType ?? "application/json"}`,
+        ...bodyLines,
+      ].join("\n");
+    });
+
+    return {
+      ...this.getTargetAndPath(names),
+      body: lines.join("\n\n###\n\n"),
+      importKeys: [],
+    };
+  }
+
+  zodTypeToReqDefault(zodType: z.ZodType<unknown>, name: string): unknown {
+    if (zodType instanceof z.ZodObject) {
+      return Object.fromEntries(
+        Object.keys(zodType.shape).map((key) => [
+          key,
+          this.zodTypeToReqDefault(zodType.shape[key], key),
+        ])
+      );
+    } else if (zodType instanceof z.ZodArray) {
+      return [this.zodTypeToReqDefault(zodType.element, name)];
+    } else if (zodType instanceof z.ZodString) {
+      if (name.endsWith("_at") || name.endsWith("_date") || name === "range") {
+        return DateTime.local().toSQL().slice(0, 10);
+      } else {
+        return name.toUpperCase();
+      }
+    } else if (zodType instanceof z.ZodNumber) {
+      if (name === "num") {
+        return 24;
+      }
+      return zodType.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);
+    } else if (zodType instanceof z.ZodNullable) {
+      return null;
+    } else if (zodType instanceof z.ZodUnion) {
+      return this.zodTypeToReqDefault(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) =>
+        this.zodTypeToReqDefault(item, name)
+      );
+    } else {
+      // console.log(zodType);
+      return `unknown-${zodType._type}`;
+    }
+  }
+
+  resolveApiParams(
+    api: ExtendedApi,
+    references: { [typeName: string]: z.ZodObject<any> }
+  ): { [key: string]: unknown } {
+    const reqType = getZodObjectFromApi(api, references);
+    return this.zodTypeToReqDefault(reqType, "unknownName") as {
+      [key: string]: unknown;
+    };
+  }
+}

package/src/templates/index.ts

@@ -0,0 +1 @@
+export * from "./base-template";

package/src/templates/init_enums.template.ts

@@ -0,0 +1,71 @@
+import { camelize } from "inflection";
+import { TemplateOptions } from "../types/types";
+import { SMDManager, SMDNamesRecord } from "../smd/smd-manager";
+import { Template } from "./base-template";
+
+export class Template__init_enums extends Template {
+  constructor() {
+    super("init_enums");
+  }
+
+  getTargetAndPath(names: SMDNamesRecord) {
+    return {
+      target: "api/src/application",
+      path: `${names.fs}/${names.fs}.enums.ts`,
+    };
+  }
+
+  render(options: TemplateOptions["init_enums"]) {
+    const { smdId, def } = options;
+    const names = SMDManager.getNamesFromId(smdId);
+
+    const record = def ?? {};
+    record.ORDER_BY ??= {
+      "id-desc": "최신순",
+    };
+    record.SEARCH_FIELD ??= {
+      id: "ID",
+    };
+
+    return {
+      ...this.getTargetAndPath(names),
+      body: `
+import { z } from "zod";
+import { EnumsLabelKo } from "../../types/shared";
+
+${Object.entries(record)
+  .map(
+    ([key, value]) => `export const ${smdId}${camelize(
+      key.toLowerCase(),
+      false
+    )} = z.enum([${Object.keys(value)
+      .map((v) => `"${v}"`)
+      .join(",")}]);
+export type ${smdId}${camelize(
+      key.toLowerCase(),
+      false
+    )} = z.infer<typeof ${smdId}${camelize(key.toLowerCase(), false)}>;`
+  )
+  .join("\n")}
+
+export namespace ${names.constant} {
+  ${Object.entries(record)
+    .map(
+      ([key, value]) => `// ${key}
+export const ${key}:EnumsLabelKo<${smdId}${camelize(
+        key.toLowerCase(),
+        false
+      )}> = {
+  ${Object.entries(value)
+    .map(([ek, ev]) => `"${ek}": { ko: "${ev}" }`)
+    .join(",")}
+};
+      `
+    )
+    .join("\n")}
+}
+      `.trim(),
+      importKeys: [],
+    };
+  }
+}

package/src/templates/init_generated.template.ts

@@ -0,0 +1,44 @@
+import { TemplateOptions } from "../types/types";
+import { SMDManager, SMDNamesRecord } from "../smd/smd-manager";
+import { Template } from "./base-template";
+
+export class Template__init_generated extends Template {
+  constructor() {
+    super("init_generated");
+  }
+
+  getTargetAndPath(names: SMDNamesRecord) {
+    return {
+      target: "api/src/application",
+      path: `${names.fs}/${names.fs}.generated.ts`,
+    };
+  }
+
+  render({ smdId }: TemplateOptions["init_generated"]) {
+    const names = SMDManager.getNamesFromId(smdId);
+
+    return {
+      ...this.getTargetAndPath(names),
+      body: `
+import { z } from "zod";
+import { ${smdId}SearchField, ${smdId}OrderBy } from "./${names.fs}.enums";
+
+export const ${smdId}BaseSchema = z.object({});
+export type ${smdId}BaseSchema = z.infer<typeof ${smdId}BaseSchema>;
+
+export const ${smdId}BaseListParams = z.object({
+  num: z.number().int().min(0),
+  page: z.number().int().min(1),
+  search: ${smdId}SearchField,
+  keyword: z.string(),
+  orderBy: ${smdId}OrderBy,
+  withoutCount: z.boolean(),
+});
+export type ${smdId}BaseListParams = z.infer<typeof ${smdId}BaseListParams>;
+
+export type ${smdId}FieldExpr = string;
+      `.trim(),
+      importKeys: [],
+    };
+  }
+}

package/src/templates/init_types.template.ts

@@ -0,0 +1,38 @@
+import { TemplateOptions } from "../types/types";
+import { SMDManager, SMDNamesRecord } from "../smd/smd-manager";
+import { Template } from "./base-template";
+
+export class Template__init_types extends Template {
+  constructor() {
+    super("init_types");
+  }
+
+  getTargetAndPath(names: SMDNamesRecord) {
+    return {
+      target: "api/src/application",
+      path: `${names.fs}/${names.fs}.types.ts`,
+    };
+  }
+
+  render({ smdId }: TemplateOptions["init_types"]) {
+    const names = SMDManager.getNamesFromId(smdId);
+
+    return {
+      ...this.getTargetAndPath(names),
+      body: `
+import { z } from "zod";
+import { ${smdId}BaseSchema, ${smdId}BaseListParams } from "./${names.fs}.generated";
+
+// ${smdId} - ListParams
+export const ${smdId}ListParams = ${smdId}BaseListParams;
+export type ${smdId}ListParams = z.infer<typeof ${smdId}ListParams>;
+
+// ${smdId} - SaveParams
+export const ${smdId}SaveParams = ${smdId}BaseSchema.partial({ id: true });
+export type ${smdId}SaveParams = z.infer<typeof ${smdId}SaveParams>;
+
+      `.trim(),
+      importKeys: [],
+    };
+  }
+}

package/src/templates/model.template.ts

@@ -0,0 +1,168 @@
+import { RenderingNode, TemplateOptions } from "../types/types";
+import { SMDManager, SMDNamesRecord } from "../smd/smd-manager";
+import { Template } from "./base-template";
+import { Template__view_list } from "./view_list.template";
+
+export class Template__model extends Template {
+  constructor() {
+    super("model");
+  }
+
+  getTargetAndPath(names: SMDNamesRecord) {
+    return {
+      target: "api/src/application",
+      path: `${names.fs}/${names.fs}.model.ts`,
+    };
+  }
+
+  render(
+    { smdId }: TemplateOptions["model"],
+    _columnsNode: RenderingNode,
+    listParamsNode: RenderingNode
+  ) {
+    const names = SMDManager.getNamesFromId(smdId);
+    const smd = SMDManager.get(smdId);
+
+    const vlTpl = new Template__view_list();
+    const def = vlTpl.getDefault(listParamsNode.children!);
+
+    return {
+      ...this.getTargetAndPath(names),
+      body: `
+import { BaseModelClass, ListResult, asArray, NotFoundException, BadRequestException, api } from '@sonamu/core';
+import {
+  ${smdId}SubsetKey,
+  ${smdId}SubsetMapping,
+  ${names.camel}SubsetQueries,
+} from "./${names.fs}.generated";
+import { ${smdId}ListParams, ${smdId}SaveParams } from "./${names.fs}.types";
+
+/*
+  ${smdId} Model
+*/
+class ${smdId}ModelClass extends BaseModelClass {
+  modelName = "${smdId}";
+
+  @api({ httpMethod: "GET", clients: ["axios", "swr"], resourceName: "${smdId}" })
+  async findById<T extends ${smdId}SubsetKey>(
+    subset: T,
+    id: number
+  ): Promise<${smdId}SubsetMapping[T]> {
+    const { rows } = await this.findMany(subset, {
+      id,
+      num: 1,
+      page: 1,
+    });
+    if (rows.length == 0) {
+      throw new NotFoundException(\`존재하지 않는 ${names.capital} ID \${id}\`);
+    }
+
+    return rows[0];
+  }
+
+  async findOne<T extends ${smdId}SubsetKey>(
+    subset: T,
+    listParams: ${smdId}ListParams
+  ): Promise<${smdId}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 ${smdId}SubsetKey>(
+    subset: T,
+    params: ${smdId}ListParams = {}
+  ): Promise<ListResult<${smdId}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("${smd.table}.id", asArray(params.id));
+        }
+
+        // search-keyword
+        if (params.search && params.keyword && params.keyword.length > 0) {
+          if (params.search === "id") {
+            qb.where("${smd.table}.id", "like", \`%\${params.keyword}%\`);
+          } else {
+            throw new BadRequestException(
+              \`구현되지 않은 검색 필드 \${params.search}\`
+            );
+          }
+        }
+
+        // orderBy
+        if (params.orderBy) {
+          // default orderBy
+          const [orderByField, orderByDirec] = params.orderBy.split("-");
+          qb.orderBy("${smd.table}." + orderByField, orderByDirec);
+        }
+
+        return qb;
+      },
+      debug: false,
+    });
+
+    return {
+      rows,
+      total,
+    };
+  }
+
+  @api({ httpMethod: "POST" })
+  async save(
+    saveParamsArray: ${smdId}SaveParams[]
+  ): Promise<number[]> {
+    const wdb = this.getDB("w");
+    const ub = this.getUpsertBuilder();
+
+    // register
+    saveParamsArray.map((saveParams) => {
+      ub.register("${smd.table}", saveParams);
+    });
+
+    // transaction
+    return wdb.transaction(async (trx) => {
+      const ids = await ub.upsert(trx, "${smd.table}");
+
+      return ids;
+    });
+  }
+
+  @api({ httpMethod: "GET" })
+  async del(ids: number[]): Promise<number> {
+    const wdb = this.getDB("w");
+
+    // transaction
+    await wdb.transaction(async (trx) => {
+      return trx("${smd.table}").whereIn("${smd.table}.id", ids).delete();
+    });
+
+    return ids.length;
+  }
+}
+
+export const ${smdId}Model = new ${smdId}ModelClass();
+      `.trim(),
+      importKeys: [],
+    };
+  }
+}