sonamu 0.5.7 → 0.7.0

package/dist/template/implementations/view_list.template.js

@@ -0,0 +1,475 @@
+import assert from "assert";
+import inflection from "inflection";
+import { flat, unique } from "radashi";
+import { z } from "zod";
+import { EntityManager } from "../../entity/entity-manager.js";
+import { getColumnsNode } from "../entity-converter.js";
+import { getEnumInfoFromColName, getRelationPropFromColName } from "../helpers.js";
+import { Template } from "../template.js";
+import { getZodTypeById, zodTypeToRenderingNode } from "../zod-converter.js";
+export class Template__view_list extends Template {
+    constructor(){
+        super("view_list");
+    }
+    getTargetAndPath(names) {
+        return {
+            target: "web/src/pages/admin",
+            path: `${names.fsPlural}/index.tsx`
+        };
+    }
+    wrapTc(body, key, collapsing = true, className = "") {
+        return `<Table.Cell key="${key}"${collapsing ? " collapsing" : ""}${className ? ` className={\`${className}\`}` : ""}>${body}</Table.Cell>`;
+    }
+    renderColumn(entityId, col, names, parentObj = "row", withoutName = false) {
+        const colName = withoutName ? `${parentObj}` : `${parentObj}.${col.name}`;
+        switch(col.renderType){
+            case "string-plain":
+            case "string-date":
+            case "number-id":
+                return `<>{${colName}}</>`;
+            case "number-fk_id":
+                {
+                    const relPropFk = getRelationPropFromColName(entityId, col.name.replace("_id", ""));
+                    return `<>${relPropFk.with}#{${colName}}</>`;
+                }
+            case "string-image":
+                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>`;
+                } else {
+                    return `<span className="text-tiny">{dateF(${colName})}</span>`;
+                }
+            case "boolean":
+                return `<>{${colName} ? <Label color='green' circular>O</Label> : <Label color='grey' circular>X</Label> }</>`;
+            case "enums":
+                {
+                    const { id: enumId } = getEnumInfoFromColName(entityId, col.name);
+                    return `<>{${col.nullable ? `${colName} && ` : ""}${enumId}Label[${colName}]}</>`;
+                }
+            case "array-images":
+                return `<>{ ${colName}.map(r => ${col.nullable ? `r && ` : ""}<img src={r} />) }</>`;
+            case "number-plain":
+                return `<>{${col.nullable ? `${colName} && ` : ""}numF(${colName})}</>`;
+            case "object":
+                return `<>{/* object ${colName} */}</>`;
+            case "object-pick":
+                {
+                    const pickedChild = col.children?.find((child)=>child.name === col.config?.picked);
+                    if (!pickedChild) {
+                        throw new Error(`object-pick 선택 실패 (오브젝트: ${col.name})`);
+                    }
+                    return this.renderColumn(entityId, pickedChild, names, `${colName}${col.nullable ? "?" : ""}`);
+                }
+            case "array":
+                return `<>{ /* array ${colName} */ }</>`;
+            default:
+                throw new Error(`렌더 불가 컬럼 ${col.renderType}`);
+        }
+    }
+    renderColumnImport(entityId, col, names) {
+        if (col.renderType === "enums") {
+            const { id: enumId } = getEnumInfoFromColName(names.capital, col.name);
+            return [
+                `import { ${enumId}Label } from 'src/services/sonamu.generated';`
+            ];
+        } else if (col.renderType === "object") {
+            try {
+                const relProp = getRelationPropFromColName(entityId, col.name);
+                const result = col.children?.map((child)=>{
+                    entityId = relProp.with;
+                    names = EntityManager.getNamesFromId(relProp.with);
+                    return this.renderColumnImport(entityId, child, names);
+                });
+                return flat(result ?? []);
+            } catch  {
+                return [
+                    null
+                ];
+            }
+        } else if (col.renderType === "array") {
+            assert(col.element);
+            return this.renderColumnImport(entityId, col.element, names);
+        }
+        return [
+            null
+        ];
+    }
+    renderFilterImport(entityId, col, names) {
+        if (col.name === "search") {
+            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`;
+                return `import { ${componentId} } from "src/components/${names.fs}/${componentId}";`;
+            } else {
+                try {
+                    const { id, targetEntityNames: targetMDNames } = getEnumInfoFromColName(entityId, col.name);
+                    const componentId = `${id}Select`;
+                    return `import { ${componentId} } from "src/components/${targetMDNames.fs}/${componentId}";`;
+                } catch  {
+                    return "";
+                }
+            }
+        } else if (col.renderType === "number-fk_id") {
+            try {
+                const relProp = getRelationPropFromColName(entityId, col.name.replace("_id", ""));
+                const targetNames = EntityManager.getNamesFromId(relProp.with);
+                const componentId = `${relProp.with}IdAsyncSelect`;
+                return `import { ${componentId} } from "src/components/${targetNames.fs}/${componentId}";`;
+            } catch  {
+                return "";
+            }
+        } else {
+            throw new Error(`렌더 불가능한 필터 임포트 ${col.name} ${col.renderType}`);
+        }
+    }
+    renderFilter(entityId, col, names) {
+        if (col.name === "search") {
+            return "";
+        }
+        const isClearable = col.optional === true && col.name !== "orderBy";
+        let componentId;
+        if (col.renderType === "enums") {
+            if (col.name === "orderBy") {
+                componentId = `${names.capital}${inflection.camelize(col.name)}Select`;
+            } else {
+                try {
+                    const { id } = getEnumInfoFromColName(entityId, col.name);
+                    componentId = `${id}Select`;
+                } catch  {
+                    return "";
+                }
+            }
+            return `<${componentId} {...register('${col.name}')} ${isClearable ? "clearable" : ""} />`;
+        } else if (col.renderType === "number-fk_id") {
+            try {
+                const relProp = getRelationPropFromColName(entityId, col.name.replace("_id", ""));
+                componentId = `${relProp.with}IdAsyncSelect`;
+                return `<${componentId} {...register('${col.name}')} ${isClearable ? "clearable" : ""} subset="A" />`;
+            } catch  {
+                return "";
+            }
+        } else {
+            throw new Error(`렌더 불가능한 필터 임포트 ${col.name} ${col.renderType}`);
+        }
+    }
+    getDefault(columns) {
+        const def = {
+            orderBy: "id-desc",
+            search: "title"
+        };
+        const orderByZodType = columns.find((col)=>col.name === "orderBy")?.zodType;
+        if (orderByZodType && orderByZodType instanceof z.ZodEnum) {
+            def.orderBy = orderByZodType.options[0].toString();
+        }
+        const searchZodType = columns.find((col)=>col.name === "search")?.zodType;
+        if (searchZodType && searchZodType instanceof z.ZodEnum) {
+            def.search = searchZodType.options[0].toString();
+        }
+        return def;
+    }
+    async render({ entityId }) {
+        const columnsNode = await getColumnsNode(entityId, "A");
+        const listParamsZodType = await getZodTypeById(`${entityId}ListParams`);
+        const listParamsNode = zodTypeToRenderingNode(listParamsZodType);
+        const names = EntityManager.getNamesFromId(entityId);
+        const entity = EntityManager.get(entityId);
+        // 실제 리스트 컬럼
+        const columns = columnsNode.children.filter((col)=>col.name !== "id").map((col)=>{
+            const propCandidate = entity.props.find((p)=>p.name === col.name);
+            return {
+                name: col.name,
+                label: propCandidate?.desc ?? col.label,
+                tc: `(row) => ${this.renderColumn(entityId, col, names)}`
+            };
+        });
+        // 필터 컬럼
+        const filterColumns = listParamsNode.children.filter((col)=>col.name !== "id" && col.name !== "queryMode" && ([
+                "enums",
+                "number-id"
+            ].includes(col.renderType) || col.name.endsWith("_id")))// orderBy가 가장 뒤로 오게 순서 조정
+        .sort((a)=>{
+            return a.name === "orderBy" ? 1 : -1;
+        });
+        // 필터 컬럼을 프리 템플릿으로 설정
+        const preTemplates = [];
+        for (const col of filterColumns){
+            let key;
+            let targetEntityId = entityId;
+            let enumId;
+            if (col.renderType === "enums") {
+                if (col.name === "search") {
+                    key = "view_enums_dropdown";
+                    enumId = `${names.capital}SearchField`;
+                    targetEntityId = names.capital;
+                } else {
+                    key = "view_enums_select";
+                    try {
+                        const { targetEntityNames, id } = getEnumInfoFromColName(entityId, col.name);
+                        targetEntityId = targetEntityNames.capital;
+                        enumId = id;
+                    } catch  {
+                        continue;
+                    }
+                }
+            } else {
+                key = "view_id_async_select";
+                try {
+                    const relProp = getRelationPropFromColName(entityId, col.name.replace("_id", ""));
+                    targetEntityId = relProp.with;
+                } catch  {
+                    continue;
+                }
+            }
+            preTemplates.push({
+                key,
+                options: {
+                    entityId: targetEntityId,
+                    enumId
+                }
+            });
+        }
+        // 리스트 컬럼
+        assert(columnsNode.children);
+        const columnImports = unique(columnsNode.children.flatMap((col)=>{
+            return this.renderColumnImport(entityId, col, names);
+        }).filter((col)=>col !== null)).join("\n");
+        // SearchInput
+        assert(preTemplates);
+        preTemplates.push({
+            key: "view_search_input",
+            options: {
+                entityId
+            }
+        });
+        // 디폴트 파라미터
+        const def = this.getDefault(filterColumns);
+        return {
+            ...this.getTargetAndPath(names),
+            body: `
+import React from 'react';
+import { Link } from 'react-router-dom';
+import {
+  Breadcrumb,
+  Checkbox,
+  Pagination,
+  Segment,
+  Table,
+  TableRow,
+  Message,
+  Transition,
+  Button,
+  Label,
+} from 'semantic-ui-react';
+import classNames from 'classnames';
+import { DateTime } from "luxon";
+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}/${names.fs}.service';
+import { ${names.capital}ListParams } from 'src/services/${names.fs}/${names.fs}.types';
+${columnImports}
+${filterColumns.map((col)=>{
+                return this.renderFilterImport(entityId, col, names);
+            }).join("\n")}
+
+type ${names.capital}ListProps = {};
+export default function ${names.capital}List({}: ${names.capital}ListProps) {
+  // 리스트 필터
+  const { listParams, register } = useListParams(${names.capital}ListParams, {
+    num: 12,
+    page: 1,
+    orderBy: '${def.orderBy}',
+    search: '${def.search}',
+  });
+
+  // 리스트 쿼리
+  const { data, mutate, error, isLoading } = ${names.capital}Service.use${names.capitalPlural}('A', listParams);
+  const { rows, total } = data ?? {};
+
+  // 삭제
+  const confirmDel = (ids: number[]) => {
+    const answer = confirm('삭제하시겠습니까?');
+    if (!answer) {
+      return;
+    }
+
+    ${names.capital}Service.del(ids).then(() => {
+      mutate();
+    });
+  };
+
+  // 일괄 삭제
+  const confirmDelSelected = () => {
+    const answer = confirm(\`\${selectedKeys.length}건을 일괄 삭제하시겠습니까?\`);
+    if (!answer) {
+      return;
+    }
+
+    ${names.capital}Service.del(selectedKeys).then(() => {
+      mutate();
+    });
+  };
+
+  // 현재 경로와 타이틀
+  const PAGE = {
+    route: '/admin/${names.fsPlural}',
+    title: '${entity.title ?? names.capital}',
+  };
+
+  // 선택
+  const {
+    getSelected,
+    isAllSelected,
+    selectedKeys,
+    toggle,
+    selectAll,
+    deselectAll,
+    handleCheckboxClick,
+  } = useSelection((rows ?? []).map((row) => row.id));
+
+  // 컬럼
+  const columns:SonamuCol<${names.capital}SubsetA>[] = [${columns.map((col)=>{
+                return [
+                    `{ label: "${col.label}",`,
+                    `tc: ${col.tc}, `,
+                    `collapsing: ${[
+                        "Title",
+                        "Name"
+                    ].includes(col.label) === false}, }`
+                ].join("\n");
+            }).join(",\n")}];
+
+  return (
+    <div className="list ${names.fsPlural}-index">
+      <div className="top-nav">
+        <div className="header-row">
+          <div className="header">{PAGE.title}</div>
+          <AppBreadcrumbs>
+            <Breadcrumb.Section active>{PAGE.title}</Breadcrumb.Section>
+          </AppBreadcrumbs>
+          <${names.capital}SearchInput
+            input={register('keyword')}
+            dropdown={register('search')}
+          />
+        </div>
+        <div className="filters-row">
+          ${filterColumns.map((col)=>{
+                return this.renderFilter(entityId, col, names);
+            }).join("&nbsp;\n")}
+        </div>
+      </div>
+
+      <Segment basic padded className="contents-segment" loading={isLoading}>
+        <div className="buttons-row">
+          <div className={classNames('count', { hidden: isLoading })}>
+            {total} 건
+          </div>
+          <div className="buttons">
+            <AddButton currentRoute={PAGE.route} icon="write" label="추가" />
+          </div>
+        </div>
+
+        <Table
+          celled
+          compact
+          selectable
+          className={classNames({ hidden: total === undefined || total === 0 })}
+        >
+          <Table.Header>
+            <TableRow>
+              <Table.HeaderCell collapsing>
+                <Checkbox
+                  label="ID"
+                  checked={isAllSelected}
+                  onChange={isAllSelected ? deselectAll : selectAll}
+                />
+              </Table.HeaderCell>
+              {
+                /* Header */
+                columns.map((col, index) => col.th ?? <Table.HeaderCell key={index} collapsing={col.collapsing}>{ col.label }</Table.HeaderCell>)
+              }
+              <Table.HeaderCell>관리</Table.HeaderCell>
+            </TableRow>
+          </Table.Header>
+          <Table.Body>
+            {rows &&
+              rows.map((row, rowIndex) => (
+                <Table.Row key={row.id}>
+                  <Table.Cell>
+                    <Checkbox
+                      label={row.id}
+                      checked={getSelected(row.id)}
+                      onChange={() => toggle(row.id)}
+                      onClick={(e) =>
+                        handleCheckboxClick(e, rowIndex)
+                      }
+                    />
+                  </Table.Cell>
+                  {
+                    /* Body */
+                    columns.map((col, colIndex) => (
+                      <Table.Cell key={colIndex} collapsing={col.collapsing} className={col.className}>
+                        {col.tc(row, rowIndex)}
+                      </Table.Cell>
+                    ))
+                  }
+                  <Table.Cell collapsing>
+                    <EditButton
+                      as={Link}
+                      to={\`\${PAGE.route}/form?id=\${row.id}\`}
+                      state={{ from: PAGE.route }}
+                    />
+                    <DelButton onClick={() => confirmDel([row.id])} />
+                  </Table.Cell>
+                </Table.Row>
+              ))}
+          </Table.Body>
+        </Table>
+        <div
+          className={classNames('pagination-row', {
+            hidden: (total ?? 0) === 0,
+          })}
+        >
+          <Pagination
+            totalPages={Math.ceil((total ?? 0) / (listParams.num ?? 24))}
+            {...register('page')}
+          />
+        </div>
+      </Segment>
+
+      <div className="fixed-menu">
+        <Transition
+          visible={selectedKeys.length > 0}
+          animation="slide left"
+          duration={500}
+        >
+          <Message size="small" color="violet" className="text-center">
+            <span className="px-4">{selectedKeys.length}개 선택됨</span>
+            <Button size="tiny" color="violet" onClick={() => deselectAll()}>
+              선택 해제
+            </Button>
+            <Button size="tiny" color="red" onClick={confirmDelSelected}>
+              일괄 삭제
+            </Button>
+          </Message>
+        </Transition>
+      </div>
+    </div>
+  );
+}
+      `.trim(),
+            importKeys: [],
+            preTemplates
+        };
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/template/implementations/view_list.template.ts"],"sourcesContent":["import assert from \"assert\";\nimport inflection from \"inflection\";\nimport { flat, unique } from \"radashi\";\nimport { z } from \"zod\";\nimport { EntityManager, type EntityNamesRecord } from \"../../entity/entity-manager\";\nimport type { RenderingNode, TemplateKey, TemplateOptions } from \"../../types/types\";\nimport { getColumnsNode } from \"../entity-converter\";\nimport { getEnumInfoFromColName, getRelationPropFromColName } from \"../helpers\";\nimport type { RenderedTemplate } from \"../template\";\nimport { Template } from \"../template\";\nimport { getZodTypeById, zodTypeToRenderingNode } from \"../zod-converter\";\n\nexport class Template__view_list extends Template {\n  constructor() {\n    super(\"view_list\");\n  }\n\n  getTargetAndPath(names: EntityNamesRecord) {\n    return {\n      target: \"web/src/pages/admin\",\n      path: `${names.fsPlural}/index.tsx`,\n    };\n  }\n\n  wrapTc(body: string, key: string, collapsing: boolean = true, className: string = \"\") {\n    return `<Table.Cell key=\"${key}\"${collapsing ? \" collapsing\" : \"\"}${\n      className ? ` className={\\`${className}\\`}` : \"\"\n    }>${body}</Table.Cell>`;\n  }\n\n  renderColumn(\n    entityId: string,\n    col: RenderingNode,\n    names: EntityNamesRecord,\n    parentObj: string = \"row\",\n    withoutName: boolean = false,\n  ): string {\n    const colName = withoutName ? `${parentObj}` : `${parentObj}.${col.name}`;\n\n    switch (col.renderType) {\n      case \"string-plain\":\n      case \"string-date\":\n      case \"number-id\":\n        return `<>{${colName}}</>`;\n      case \"number-fk_id\": {\n        const relPropFk = getRelationPropFromColName(entityId, col.name.replace(\"_id\", \"\"));\n        return `<>${relPropFk.with}#{${colName}}</>`;\n      }\n      case \"string-image\":\n        return `<>{${col.nullable ? `${colName} && ` : \"\"}<img src={${colName}} />}</>`;\n      case \"datetime\":\n        if (col.nullable) {\n          return `<span className=\"text-tiny\">{${colName} === null ? '-' : formatDateTime(${colName})}</span>`;\n        } else {\n          return `<span className=\"text-tiny\">{formatDateTime(${colName})}</span>`;\n        }\n      case \"string-datetime\":\n        if (col.nullable) {\n          return `<span className=\"text-tiny\">{${colName} === null ? '-' : dateF(${colName})}</span>`;\n        } else {\n          return `<span className=\"text-tiny\">{dateF(${colName})}</span>`;\n        }\n      case \"boolean\":\n        return `<>{${colName} ? <Label color='green' circular>O</Label> : <Label color='grey' circular>X</Label> }</>`;\n      case \"enums\": {\n        const { id: enumId } = getEnumInfoFromColName(entityId, col.name);\n        return `<>{${col.nullable ? `${colName} && ` : \"\"}${enumId}Label[${colName}]}</>`;\n      }\n      case \"array-images\":\n        return `<>{ ${colName}.map(r => ${col.nullable ? `r && ` : \"\"}<img src={r} />) }</>`;\n      case \"number-plain\":\n        return `<>{${col.nullable ? `${colName} && ` : \"\"}numF(${colName})}</>`;\n      case \"object\":\n        return `<>{/* object ${colName} */}</>`;\n      case \"object-pick\": {\n        const pickedChild = col.children?.find((child) => child.name === col.config?.picked);\n        if (!pickedChild) {\n          throw new Error(`object-pick 선택 실패 (오브젝트: ${col.name})`);\n        }\n        return this.renderColumn(\n          entityId,\n          pickedChild,\n          names,\n          `${colName}${col.nullable ? \"?\" : \"\"}`,\n        );\n      }\n      case \"array\":\n        return `<>{ /* array ${colName} */ }</>`;\n      default:\n        throw new Error(`렌더 불가 컬럼 ${col.renderType}`);\n    }\n  }\n\n  renderColumnImport(\n    entityId: string,\n    col: RenderingNode,\n    names: EntityNamesRecord,\n  ): (string | null)[] {\n    if (col.renderType === \"enums\") {\n      const { id: enumId } = getEnumInfoFromColName(names.capital, col.name);\n      return [`import { ${enumId}Label } from 'src/services/sonamu.generated';`];\n    } else if (col.renderType === \"object\") {\n      try {\n        const relProp = getRelationPropFromColName(entityId, col.name);\n        const result = col.children?.map((child) => {\n          entityId = relProp.with;\n          names = EntityManager.getNamesFromId(relProp.with);\n          return this.renderColumnImport(entityId, child, names);\n        });\n        return flat(result ?? []);\n      } catch {\n        return [null];\n      }\n    } else if (col.renderType === \"array\") {\n      assert(col.element);\n      return this.renderColumnImport(entityId, col.element, names);\n    }\n\n    return [null];\n  }\n\n  renderFilterImport(entityId: string, col: RenderingNode, names: EntityNamesRecord) {\n    if (col.name === \"search\") {\n      return `import { ${names.capital}SearchInput } from \"src/components/${names.fs}/${names.capital}SearchInput\";`;\n    } else if (col.renderType === \"enums\") {\n      if (col.name === \"orderBy\") {\n        const componentId = `${names.capital}${inflection.camelize(col.name)}Select`;\n        return `import { ${componentId} } from \"src/components/${names.fs}/${componentId}\";`;\n      } else {\n        try {\n          const { id, targetEntityNames: targetMDNames } = getEnumInfoFromColName(\n            entityId,\n            col.name,\n          );\n          const componentId = `${id}Select`;\n          return `import { ${componentId} } from \"src/components/${targetMDNames.fs}/${componentId}\";`;\n        } catch {\n          return \"\";\n        }\n      }\n    } else if (col.renderType === \"number-fk_id\") {\n      try {\n        const relProp = getRelationPropFromColName(entityId, col.name.replace(\"_id\", \"\"));\n        const targetNames = EntityManager.getNamesFromId(relProp.with);\n        const componentId = `${relProp.with}IdAsyncSelect`;\n        return `import { ${componentId} } from \"src/components/${targetNames.fs}/${componentId}\";`;\n      } catch {\n        return \"\";\n      }\n    } else {\n      throw new Error(`렌더 불가능한 필터 임포트 ${col.name} ${col.renderType}`);\n    }\n  }\n\n  renderFilter(entityId: string, col: RenderingNode, names: EntityNamesRecord) {\n    if (col.name === \"search\") {\n      return \"\";\n    }\n\n    const isClearable = col.optional === true && col.name !== \"orderBy\";\n    let componentId: string;\n    if (col.renderType === \"enums\") {\n      if (col.name === \"orderBy\") {\n        componentId = `${names.capital}${inflection.camelize(col.name)}Select`;\n      } else {\n        try {\n          const { id } = getEnumInfoFromColName(entityId, col.name);\n          componentId = `${id}Select`;\n        } catch {\n          return \"\";\n        }\n      }\n      return `<${componentId} {...register('${col.name}')} ${isClearable ? \"clearable\" : \"\"} />`;\n    } else if (col.renderType === \"number-fk_id\") {\n      try {\n        const relProp = getRelationPropFromColName(entityId, col.name.replace(\"_id\", \"\"));\n        componentId = `${relProp.with}IdAsyncSelect`;\n        return `<${componentId} {...register('${col.name}')} ${\n          isClearable ? \"clearable\" : \"\"\n        } subset=\"A\" />`;\n      } catch {\n        return \"\";\n      }\n    } else {\n      throw new Error(`렌더 불가능한 필터 임포트 ${col.name} ${col.renderType}`);\n    }\n  }\n\n  getDefault(columns: RenderingNode[]): {\n    orderBy: string;\n    search: string;\n  } {\n    const def = {\n      orderBy: \"id-desc\",\n      search: \"title\",\n    };\n    const orderByZodType = columns.find((col) => col.name === \"orderBy\")?.zodType;\n    if (orderByZodType && orderByZodType instanceof z.ZodEnum) {\n      def.orderBy = orderByZodType.options[0].toString();\n    }\n    const searchZodType = columns.find((col) => col.name === \"search\")?.zodType;\n    if (searchZodType && searchZodType instanceof z.ZodEnum) {\n      def.search = searchZodType.options[0].toString();\n    }\n    return def;\n  }\n\n  async render({ entityId }: TemplateOptions[\"view_list\"]) {\n    const columnsNode = await getColumnsNode(entityId, \"A\");\n    const listParamsZodType = await getZodTypeById(`${entityId}ListParams`);\n    const listParamsNode = zodTypeToRenderingNode(listParamsZodType);\n\n    const names = EntityManager.getNamesFromId(entityId);\n    const entity = EntityManager.get(entityId);\n\n    // 실제 리스트 컬럼\n    const columns = (columnsNode.children as RenderingNode[])\n      .filter((col) => col.name !== \"id\")\n      .map((col) => {\n        const propCandidate = entity.props.find((p) => p.name === col.name);\n        return {\n          name: col.name,\n          label: propCandidate?.desc ?? col.label,\n          tc: `(row) => ${this.renderColumn(entityId, col, names)}`,\n        };\n      });\n\n    // 필터 컬럼\n    const filterColumns = (listParamsNode.children as RenderingNode[])\n      .filter(\n        (col) =>\n          col.name !== \"id\" &&\n          col.name !== \"queryMode\" &&\n          ([\"enums\", \"number-id\"].includes(col.renderType) || col.name.endsWith(\"_id\")),\n      )\n      // orderBy가 가장 뒤로 오게 순서 조정\n      .sort((a) => {\n        return a.name === \"orderBy\" ? 1 : -1;\n      });\n\n    // 필터 컬럼을 프리 템플릿으로 설정\n    const preTemplates: RenderedTemplate[\"preTemplates\"] = [];\n    for (const col of filterColumns) {\n      let key: TemplateKey;\n      let targetEntityId = entityId;\n      let enumId: string | undefined;\n\n      if (col.renderType === \"enums\") {\n        if (col.name === \"search\") {\n          key = \"view_enums_dropdown\";\n          enumId = `${names.capital}SearchField`;\n          targetEntityId = names.capital;\n        } else {\n          key = \"view_enums_select\";\n          try {\n            const { targetEntityNames, id } = getEnumInfoFromColName(entityId, col.name);\n            targetEntityId = targetEntityNames.capital;\n            enumId = id;\n          } catch {\n            continue;\n          }\n        }\n      } else {\n        key = \"view_id_async_select\";\n        try {\n          const relProp = getRelationPropFromColName(entityId, col.name.replace(\"_id\", \"\"));\n          targetEntityId = relProp.with;\n        } catch {\n          continue;\n        }\n      }\n\n      preTemplates.push({\n        key,\n        options: {\n          entityId: targetEntityId,\n          enumId,\n        },\n      });\n    }\n\n    // 리스트 컬럼\n    assert(columnsNode.children);\n    const columnImports = unique(\n      columnsNode.children\n        .flatMap((col) => {\n          return this.renderColumnImport(entityId, col, names);\n        })\n        .filter((col) => col !== null),\n    ).join(\"\\n\");\n\n    // SearchInput\n    assert(preTemplates);\n    preTemplates.push({\n      key: \"view_search_input\",\n      options: {\n        entityId,\n      },\n    });\n\n    // 디폴트 파라미터\n    const def = this.getDefault(filterColumns);\n\n    return {\n      ...this.getTargetAndPath(names),\n      body: `\nimport React from 'react';\nimport { Link } from 'react-router-dom';\nimport {\n  Breadcrumb,\n  Checkbox,\n  Pagination,\n  Segment,\n  Table,\n  TableRow,\n  Message,\n  Transition,\n  Button,\n  Label,\n} from 'semantic-ui-react';\nimport classNames from 'classnames';\nimport { DateTime } from \"luxon\";\nimport { DelButton, EditButton, AppBreadcrumbs, AddButton, useSelection, useListParams, SonamuCol, numF, formatDate, formatDateTime } from '@sonamu-kit/react-sui';\n\nimport { ${names.capital}SubsetA } from \"src/services/sonamu.generated\";\nimport { ${names.capital}Service } from 'src/services/${names.fs}/${names.fs}.service';\nimport { ${names.capital}ListParams } from 'src/services/${names.fs}/${names.fs}.types';\n${columnImports}\n${filterColumns\n  .map((col) => {\n    return this.renderFilterImport(entityId, col, names);\n  })\n  .join(\"\\n\")}\n\ntype ${names.capital}ListProps = {};\nexport default function ${names.capital}List({}: ${names.capital}ListProps) {\n  // 리스트 필터\n  const { listParams, register } = useListParams(${names.capital}ListParams, {\n    num: 12,\n    page: 1,\n    orderBy: '${def.orderBy}',\n    search: '${def.search}',\n  });\n\n  // 리스트 쿼리\n  const { data, mutate, error, isLoading } = ${names.capital}Service.use${\n    names.capitalPlural\n  }('A', listParams);\n  const { rows, total } = data ?? {};\n\n  // 삭제\n  const confirmDel = (ids: number[]) => {\n    const answer = confirm('삭제하시겠습니까?');\n    if (!answer) {\n      return;\n    }\n\n    ${names.capital}Service.del(ids).then(() => {\n      mutate();\n    });\n  };\n\n  // 일괄 삭제\n  const confirmDelSelected = () => {\n    const answer = confirm(\\`\\${selectedKeys.length}건을 일괄 삭제하시겠습니까?\\`);\n    if (!answer) {\n      return;\n    }\n\n    ${names.capital}Service.del(selectedKeys).then(() => {\n      mutate();\n    });\n  };\n\n  // 현재 경로와 타이틀\n  const PAGE = {\n    route: '/admin/${names.fsPlural}',\n    title: '${entity.title ?? names.capital}',\n  };\n\n  // 선택\n  const {\n    getSelected,\n    isAllSelected,\n    selectedKeys,\n    toggle,\n    selectAll,\n    deselectAll,\n    handleCheckboxClick,\n  } = useSelection((rows ?? []).map((row) => row.id));\n\n  // 컬럼\n  const columns:SonamuCol<${names.capital}SubsetA>[] = [${columns\n    .map((col) => {\n      return [\n        `{ label: \"${col.label}\",`,\n        `tc: ${col.tc}, `,\n        `collapsing: ${[\"Title\", \"Name\"].includes(col.label) === false}, }`,\n      ].join(\"\\n\");\n    })\n    .join(\",\\n\")}];\n\n  return (\n    <div className=\"list ${names.fsPlural}-index\">\n      <div className=\"top-nav\">\n        <div className=\"header-row\">\n          <div className=\"header\">{PAGE.title}</div>\n          <AppBreadcrumbs>\n            <Breadcrumb.Section active>{PAGE.title}</Breadcrumb.Section>\n          </AppBreadcrumbs>\n          <${names.capital}SearchInput\n            input={register('keyword')}\n            dropdown={register('search')}\n          />\n        </div>\n        <div className=\"filters-row\">\n          ${filterColumns\n            .map((col) => {\n              return this.renderFilter(entityId, col, names);\n            })\n            .join(\"&nbsp;\\n\")}\n        </div>\n      </div>\n\n      <Segment basic padded className=\"contents-segment\" loading={isLoading}>\n        <div className=\"buttons-row\">\n          <div className={classNames('count', { hidden: isLoading })}>\n            {total} 건\n          </div>\n          <div className=\"buttons\">\n            <AddButton currentRoute={PAGE.route} icon=\"write\" label=\"추가\" />\n          </div>\n        </div>\n\n        <Table\n          celled\n          compact\n          selectable\n          className={classNames({ hidden: total === undefined || total === 0 })}\n        >\n          <Table.Header>\n            <TableRow>\n              <Table.HeaderCell collapsing>\n                <Checkbox\n                  label=\"ID\"\n                  checked={isAllSelected}\n                  onChange={isAllSelected ? deselectAll : selectAll}\n                />\n              </Table.HeaderCell>\n              {\n                /* Header */\n                columns.map((col, index) => col.th ?? <Table.HeaderCell key={index} collapsing={col.collapsing}>{ col.label }</Table.HeaderCell>)\n              }\n              <Table.HeaderCell>관리</Table.HeaderCell>\n            </TableRow>\n          </Table.Header>\n          <Table.Body>\n            {rows &&\n              rows.map((row, rowIndex) => (\n                <Table.Row key={row.id}>\n                  <Table.Cell>\n                    <Checkbox\n                      label={row.id}\n                      checked={getSelected(row.id)}\n                      onChange={() => toggle(row.id)}\n                      onClick={(e) =>\n                        handleCheckboxClick(e, rowIndex)\n                      }\n                    />\n                  </Table.Cell>\n                  {\n                    /* Body */\n                    columns.map((col, colIndex) => (\n                      <Table.Cell key={colIndex} collapsing={col.collapsing} className={col.className}>\n                        {col.tc(row, rowIndex)}\n                      </Table.Cell>\n                    ))\n                  }\n                  <Table.Cell collapsing>\n                    <EditButton\n                      as={Link}\n                      to={\\`\\${PAGE.route}/form?id=\\${row.id}\\`}\n                      state={{ from: PAGE.route }}\n                    />\n                    <DelButton onClick={() => confirmDel([row.id])} />\n                  </Table.Cell>\n                </Table.Row>\n              ))}\n          </Table.Body>\n        </Table>\n        <div\n          className={classNames('pagination-row', {\n            hidden: (total ?? 0) === 0,\n          })}\n        >\n          <Pagination\n            totalPages={Math.ceil((total ?? 0) / (listParams.num ?? 24))}\n            {...register('page')}\n          />\n        </div>\n      </Segment>\n\n      <div className=\"fixed-menu\">\n        <Transition\n          visible={selectedKeys.length > 0}\n          animation=\"slide left\"\n          duration={500}\n        >\n          <Message size=\"small\" color=\"violet\" className=\"text-center\">\n            <span className=\"px-4\">{selectedKeys.length}개 선택됨</span>\n            <Button size=\"tiny\" color=\"violet\" onClick={() => deselectAll()}>\n              선택 해제\n            </Button>\n            <Button size=\"tiny\" color=\"red\" onClick={confirmDelSelected}>\n              일괄 삭제\n            </Button>\n          </Message>\n        </Transition>\n      </div>\n    </div>\n  );\n}\n      `.trim(),\n      importKeys: [],\n      preTemplates,\n    };\n  }\n}\n"],"names":["assert","inflection","flat","unique","z","EntityManager","getColumnsNode","getEnumInfoFromColName","getRelationPropFromColName","Template","getZodTypeById","zodTypeToRenderingNode","Template__view_list","getTargetAndPath","names","target","path","fsPlural","wrapTc","body","key","collapsing","className","renderColumn","entityId","col","parentObj","withoutName","colName","name","renderType","relPropFk","replace","with","nullable","id","enumId","pickedChild","children","find","child","config","picked","Error","renderColumnImport","capital","relProp","result","map","getNamesFromId","element","renderFilterImport","fs","componentId","camelize","targetEntityNames","targetMDNames","targetNames","renderFilter","isClearable","optional","getDefault","columns","def","orderBy","search","orderByZodType","zodType","ZodEnum","options","toString","searchZodType","render","columnsNode","listParamsZodType","listParamsNode","entity","get","filter","propCandidate","props","p","label","desc","tc","filterColumns","includes","endsWith","sort","a","preTemplates","targetEntityId","push","columnImports","flatMap","join","capitalPlural","title","trim","importKeys"],"mappings":"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"}

package/dist/template/implementations/view_list_columns.template.d.ts

@@ -0,0 +1,17 @@
+import { type EntityNamesRecord } from "../../entity/entity-manager";
+import type { TemplateOptions } from "../../types/types";
+import { Template } from "../template";
+export declare class Template__view_list_columns extends Template {
+    constructor();
+    getTargetAndPath(names: EntityNamesRecord): {
+        target: string;
+        path: string;
+    };
+    render({ entityId, columns, columnImports }: TemplateOptions["view_list_columns"]): {
+        body: string;
+        importKeys: never[];
+        target: string;
+        path: string;
+    };
+}
+//# sourceMappingURL=view_list_columns.template.d.ts.map

package/dist/template/implementations/view_list_columns.template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"view_list_columns.template.d.ts","sourceRoot":"","sources":["../../../src/template/implementations/view_list_columns.template.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AACpF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC,qBAAa,2BAA4B,SAAQ,QAAQ;;IAKvD,gBAAgB,CAAC,KAAK,EAAE,iBAAiB;;;;IAQzC,MAAM,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,aAAa,EAAE,EAAE,eAAe,CAAC,mBAAmB,CAAC;;;;;;CAmClF"}

package/dist/template/implementations/view_list_columns.template.js

@@ -0,0 +1,49 @@
+import { EntityManager } from "../../entity/entity-manager.js";
+import { Template } from "../template.js";
+export class Template__view_list_columns extends Template {
+    constructor(){
+        super("view_list_columns");
+    }
+    getTargetAndPath(names) {
+        return {
+            target: "web/src/pages/admin",
+            path: `${names.fsPlural}/_columns.tsx`
+        };
+    }
+    // 컬럼
+    render({ entityId, columns, columnImports }) {
+        const names = EntityManager.getNamesFromId(entityId);
+        return {
+            ...this.getTargetAndPath(names),
+            body: `
+import React from 'react';
+import {
+  Segment,
+  Table,
+  TableRow,
+  Button,
+  Label,
+} from 'semantic-ui-react';
+import { DateTime } from "luxon";
+import { TFColumn } from "src/typeframe/iso-types";
+import { ${names.capital}SubsetA } from "src/services/${names.fs}/${names.fs}.generated";
+${columnImports}
+
+const columns: { [key in Exclude<keyof ${names.capital}SubsetA, 'id'>]: TFColumn<${names.capital}SubsetA> } = {${columns.map((col)=>{
+                return [
+                    `${col.name}: { label: "${col.label}",`,
+                    `tc: ${col.tc}, `,
+                    `collapsing: ${[
+                        "Title",
+                        "Name"
+                    ].includes(col.label) === false}, }`
+                ].join("\n");
+            }).join(",\n")}};
+export default columns;
+      `.trim(),
+            importKeys: []
+        };
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/{templates → template/implementations}/view_search_input.template.d.ts

@@ -1,6 +1,6 @@
-import { TemplateOptions } from "../types/types";
-import { EntityNamesRecord } from "../entity/entity-manager";
-import { Template } from "./base-template";
+import { type EntityNamesRecord } from "../../entity/entity-manager";
+import type { TemplateOptions } from "../../types/types";
+import { Template } from "../template";
 export declare class Template__view_search_input extends Template {
     constructor();
     getTargetAndPath(names: EntityNamesRecord): {

package/dist/template/implementations/view_search_input.template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"view_search_input.template.d.ts","sourceRoot":"","sources":["../../../src/template/implementations/view_search_input.template.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AACpF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC,qBAAa,2BAA4B,SAAQ,QAAQ;;IAKvD,gBAAgB,CAAC,KAAK,EAAE,iBAAiB;;;;IAOzC,MAAM,CAAC,EAAE,QAAQ,EAAE,EAAE,eAAe,CAAC,mBAAmB,CAAC;;;;;;CAkD1D"}