sonamu 0.5.6 → 0.6.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"service.template.d.ts","sourceRoot":"","sources":["../../../src/template/implementations/service.template.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAgB,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAQ3D,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAGvC,qBAAa,iBAAkB,SAAQ,QAAQ;;IAK7C,gBAAgB,CAAC,KAAK,EAAE,iBAAiB;;;;IAOzC,MAAM,CAAC,EAAE,WAAW,EAAE,EAAE,eAAe,CAAC,SAAS,CAAC;;;;;;;IAmClD,aAAa,CAAC,IAAI,EAAE,WAAW,EAAE,GAAG;QAClC,KAAK,EAAE,MAAM,EAAE,CAAC;QAChB,UAAU,EAAE,MAAM,EAAE,CAAC;KACtB;IAyHD,WAAW,CACT,GAAG,EAAE,WAAW,EAChB,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,MAAM,EACrB,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,MAAM,EACrB,UAAU,EAAE,MAAM;IA8BpB,oBAAoB,CAClB,GAAG,EAAE,WAAW,EAChB,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,MAAM,EACrB,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,MAAM,EACrB,oBAAoB,EAAE,QAAQ,EAAE;IA6ClC,SAAS,CACP,GAAG,EAAE,WAAW,EAChB,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,MAAM,EACrB,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,MAAM,EACrB,UAAU,EAAE,MAAM;IAsBpB,iBAAiB,CACf,GAAG,EAAE,WAAW,EAChB,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,MAAM,EACrB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM;IAapB,YAAY,CACV,GAAG,EAAE,WAAW,EAChB,UAAU,EAAE,MAAM,EAClB,iBAAiB,EAAE,MAAM;CAuB5B"}

package/dist/template/implementations/service.template.js

@@ -0,0 +1,193 @@
+import inflection from "inflection";
+import * as _ from "lodash-es";
+import { ApiParamType } from "../../types/types.js";
+import { apiParamTypeToTsType, apiParamToTsCode, unwrapPromiseOnce, zodTypeToTsTypeDef, apiParamToTsCodeAsObject } from "../../api/code-converters.js";
+import { Template } from "../template.js";
+import { Sonamu } from "../../api/sonamu.js";
+export class Template__service extends Template {
+    constructor(){
+        super("service");
+    }
+    getTargetAndPath(names) {
+        return {
+            target: ":target/src/services",
+            path: `${names.fs}/${names.fs}.service.ts`
+        };
+    }
+    render({ namesRecord }) {
+        const { syncer: { apis } } = Sonamu;
+        const apisForThisModel = apis.filter((api)=>api.modelName === `${namesRecord.capital}Model`);
+        // 서비스 TypeSource
+        const { lines, importKeys } = this.getTypeSource(apisForThisModel);
+        // AxiosProgressEvent 있는지 확인
+        const hasAxiosProgressEvent = apis.find((api)=>(api.options.clients ?? []).includes("axios-multipart"));
+        return {
+            ...this.getTargetAndPath(namesRecord),
+            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, swrPostFetcher, EventHandlers, SSEStreamOptions, useSSEStream } from '../sonamu.shared';`,
+                ...hasAxiosProgressEvent ? [
+                    `import { AxiosProgressEvent } from 'axios';`
+                ] : []
+            ]
+        };
+    }
+    getTypeSource(apis) {
+        const importKeys = [];
+        // 제네릭에서 선언한 타입, importKeys에서 제외 필요
+        let typeParamNames = [];
+        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) && !ApiParamType.isRefKnex(param.type) && !(param.optional === true && param.name.startsWith("_") // _로 시작하는 파라미터는 제외
+                    ));
+                // 파라미터 타입 정의
+                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 paramsDefAsObject = apiParamToTsCodeAsObject(paramsWithoutContext, importKeys);
+                // 리턴 타입 정의
+                const returnTypeDef = apiParamTypeToTsType(unwrapPromiseOnce(api.returnType), importKeys);
+                // 페이로드 데이터 정의
+                const payloadDef = `{ ${paramsWithoutContext.map((param)=>param.name).join(", ")} }`;
+                // 기본 URL
+                const apiBaseUrl = `${Sonamu.config.api.route.prefix}${api.path}`;
+                return [
+                    // 클라이언트별로 생성
+                    ..._.sortBy(api.options.clients, (client)=>client === "swr" ? 0 : 1).map((client)=>{
+                        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);
+                            default:
+                                return `// Not supported ${inflection.camelize(client, true)} yet.`;
+                        }
+                    }),
+                    // 스트리밍인 경우
+                    ...api.streamOptions ? [
+                        this.renderStream(api, apiBaseUrl, paramsDefAsObject)
+                    ] : []
+                ].join("\n");
+            }).join("\n\n");
+            return `export namespace ${modelName.replace(/Model$/, "Service").replace(/Frame$/, "Service")} {
+${methodCodes}
+}`;
+        }).join("\n\n");
+        return {
+            lines: [
+                body
+            ],
+            importKeys: _.difference(_.uniq(importKeys), typeParamNames)
+        };
+    }
+    renderAxios(api, apiBaseUrl, typeParamsDef, paramsDef, returnTypeDef, payloadDef) {
+        const methodNameAxios = api.options.resourceName ? "get" + inflection.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})}\`,
+      ${api.options.timeout ? `signal: AbortSignal.timeout(${api.options.timeout}),` : ""}
+    });
+}
+    `.trim();
+        } else {
+            return `
+export async function ${methodNameAxios}${typeParamsDef}(${paramsDef}): Promise<${returnTypeDef}> {
+    return fetch({
+      method: '${api.options.httpMethod}',
+      url: \`${apiBaseUrl}\`,
+      data: ${payloadDef},
+      ${api.options.timeout ? `signal: AbortSignal.timeout(${api.options.timeout}),` : ""}
+    });
+}
+      `.trim();
+        }
+    }
+    renderAxiosMultipart(api, apiBaseUrl, typeParamsDef, paramsDef, returnTypeDef, paramsWithoutContext) {
+        const isMultiple = api.uploadOptions?.mode === "multiple";
+        const fileParamName = isMultiple ? "files" : "file";
+        const fileParamType = isMultiple ? "File[]" : "File";
+        const formDataDef = isMultiple ? [
+            `${fileParamName}.forEach(f => formData.append("${fileParamName}", f));`,
+            ...paramsWithoutContext.map((param)=>`formData.append('${param.name}', String(${param.name}));`)
+        ].join("\n") : [
+            `formData.append("${fileParamName}", ${fileParamName});`,
+            ...paramsWithoutContext.map((param)=>`formData.append('${param.name}', String(${param.name}));`)
+        ].join("\n");
+        const paramsDefComma = paramsDef !== "" ? ", " : "";
+        return `
+export async function ${api.methodName}${typeParamsDef}(
+  ${paramsDef}${paramsDefComma}
+  ${fileParamName}: ${fileParamType},
+  onUploadProgress?: (pe:AxiosProgressEvent) => void
+  ): Promise<${returnTypeDef}> {
+    const formData = new FormData();
+    ${formDataDef}
+    return fetch({
+      method: 'POST',
+      url: \`${apiBaseUrl}\`,
+      headers: {
+        "Content-Type": "multipart/form-data",
+      },
+      onUploadProgress,
+      data: formData,
+      ${api.options.timeout ? `signal: AbortSignal.timeout(${api.options.timeout}),` : ""}
+    });
+  }
+  `.trim();
+    }
+    renderSwr(api, apiBaseUrl, typeParamsDef, paramsDef, returnTypeDef, payloadDef) {
+        const methodNameSwr = api.options.resourceName ? "use" + inflection.camelize(api.options.resourceName) : "use" + inflection.camelize(api.methodName);
+        return `  export function ${inflection.camelize(methodNameSwr, true)}${typeParamsDef}(${[
+            paramsDef,
+            "swrOptions?: SwrOptions"
+        ].filter((p)=>p !== "").join(",")}, ): SWRResponse<${returnTypeDef}, SWRError> {
+    return useSWR(handleConditional([
+      \`${apiBaseUrl}\`,
+      ${payloadDef},
+    ], swrOptions?.conditional)${api.options.httpMethod === "POST" ? ", swrPostFetcher" : ""}${api.options.timeout ? `, { loadingTimeout: ${api.options.timeout} }` : ""});
+  }`;
+    }
+    renderWindowFetch(api, apiBaseUrl, typeParamsDef, paramsDef, payloadDef) {
+        return `
+export async function ${api.methodName}${typeParamsDef}(${paramsDef}): Promise<Response> {
+    return window.fetch(\`${apiBaseUrl}?\${qs.stringify(${payloadDef})}\`${api.options.timeout ? `, { signal: AbortSignal.timeout(${api.options.timeout}) }` : ""});
+}
+    `.trim();
+    }
+    renderStream(api, apiBaseUrl, paramsDefAsObject) {
+        if (!api.streamOptions) {
+            return "// streamOptions not found";
+        }
+        const methodNameStream = api.options.resourceName ? "use" + inflection.camelize(api.options.resourceName) : "use" + inflection.camelize(api.methodName);
+        const methodNameStreamCamelized = inflection.camelize(methodNameStream, true);
+        const eventsTypeDef = zodTypeToTsTypeDef(api.streamOptions.events);
+        return `  export function ${methodNameStreamCamelized}(
+  params: ${paramsDefAsObject},
+  handlers: EventHandlers<${eventsTypeDef} & { end?: () => void }>,
+  options: SSEStreamOptions) {
+    return useSSEStream<${eventsTypeDef}>(\`${apiBaseUrl}\`, params, handlers, options);
+  }`;
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/template/implementations/service.template.ts"],"sourcesContent":["import inflection from \"inflection\";\nimport * as _ from \"lodash-es\";\nimport { TemplateOptions } from \"../../types/types\";\nimport { EntityNamesRecord } from \"../../entity/entity-manager\";\nimport { ApiParamType, ApiParam } from \"../../types/types\";\nimport {\n  apiParamTypeToTsType,\n  apiParamToTsCode,\n  unwrapPromiseOnce,\n  zodTypeToTsTypeDef,\n  apiParamToTsCodeAsObject,\n} from \"../../api/code-converters\";\nimport { ExtendedApi } from \"../../api/decorators\";\nimport { Template } from \"../template\";\nimport { Sonamu } from \"../../api/sonamu\";\n\nexport class Template__service extends Template {\n  constructor() {\n    super(\"service\");\n  }\n\n  getTargetAndPath(names: EntityNamesRecord) {\n    return {\n      target: \":target/src/services\",\n      path: `${names.fs}/${names.fs}.service.ts`,\n    };\n  }\n\n  render({ namesRecord }: TemplateOptions[\"service\"]) {\n    const {\n      syncer: { apis },\n    } = Sonamu;\n\n    const apisForThisModel = apis.filter(\n      (api) => api.modelName === `${namesRecord.capital}Model`\n    );\n\n    // 서비스 TypeSource\n    const { lines, importKeys } = this.getTypeSource(apisForThisModel);\n\n    // AxiosProgressEvent 있는지 확인\n    const hasAxiosProgressEvent = apis.find((api) =>\n      (api.options.clients ?? []).includes(\"axios-multipart\")\n    );\n\n    return {\n      ...this.getTargetAndPath(namesRecord),\n      body: lines.join(\"\\n\"),\n      importKeys: importKeys.filter(\n        (key) => [\"ListResult\"].includes(key) === false\n      ),\n      customHeaders: [\n        `import { z } from 'zod';`,\n        `import qs from \"qs\";`,\n        `import useSWR, { SWRResponse } from \"swr\";`,\n        `import { fetch, ListResult, SWRError, SwrOptions, handleConditional, swrPostFetcher, EventHandlers, SSEStreamOptions, useSSEStream } from '../sonamu.shared';`,\n        ...(hasAxiosProgressEvent\n          ? [`import { AxiosProgressEvent } from 'axios';`]\n          : []),\n      ],\n    };\n  }\n\n  getTypeSource(apis: ExtendedApi[]): {\n    lines: string[];\n    importKeys: string[];\n  } {\n    const importKeys: string[] = [];\n\n    // 제네릭에서 선언한 타입, importKeys에서 제외 필요\n    let typeParamNames: string[] = [];\n\n    const groups = _.groupBy(apis, (api) => api.modelName);\n    const body = Object.keys(groups)\n      .map((modelName) => {\n        const methods = groups[modelName];\n        const methodCodes = methods\n          .map((api) => {\n            // 컨텍스트 제외된 파라미터 리스트\n            const paramsWithoutContext = api.parameters.filter(\n              (param) =>\n                !ApiParamType.isContext(param.type) &&\n                !ApiParamType.isRefKnex(param.type) &&\n                !(param.optional === true && param.name.startsWith(\"_\")) // _로 시작하는 파라미터는 제외\n            );\n\n            // 파라미터 타입 정의\n            const typeParamsDef = api.typeParameters\n              .map((typeParam) => {\n                return apiParamTypeToTsType(typeParam, importKeys);\n              })\n              .join(\", \");\n            typeParamNames = typeParamNames.concat(\n              api.typeParameters.map((typeParam) => typeParam.id)\n            );\n\n            // 파라미터 정의\n            const paramsDef = apiParamToTsCode(\n              paramsWithoutContext,\n              importKeys\n            );\n\n            // 파라미터 정의 (객체 형태)\n            const paramsDefAsObject = apiParamToTsCodeAsObject(\n              paramsWithoutContext,\n              importKeys\n            );\n\n            // 리턴 타입 정의\n            const returnTypeDef = apiParamTypeToTsType(\n              unwrapPromiseOnce(api.returnType),\n              importKeys\n            );\n\n            // 페이로드 데이터 정의\n            const payloadDef = `{ ${paramsWithoutContext\n              .map((param) => param.name)\n              .join(\", \")} }`;\n\n            // 기본 URL\n            const apiBaseUrl = `${Sonamu.config.api.route.prefix}${api.path}`;\n\n            return [\n              // 클라이언트별로 생성\n              ..._.sortBy(api.options.clients, (client) =>\n                client === \"swr\" ? 0 : 1\n              ).map((client) => {\n                switch (client) {\n                  case \"axios\":\n                    return this.renderAxios(\n                      api,\n                      apiBaseUrl,\n                      typeParamsDef,\n                      paramsDef,\n                      returnTypeDef,\n                      payloadDef\n                    );\n                  case \"axios-multipart\":\n                    return this.renderAxiosMultipart(\n                      api,\n                      apiBaseUrl,\n                      typeParamsDef,\n                      paramsDef,\n                      returnTypeDef,\n                      paramsWithoutContext\n                    );\n                  case \"swr\":\n                    return this.renderSwr(\n                      api,\n                      apiBaseUrl,\n                      typeParamsDef,\n                      paramsDef,\n                      returnTypeDef,\n                      payloadDef\n                    );\n                  case \"window-fetch\":\n                    return this.renderWindowFetch(\n                      api,\n                      apiBaseUrl,\n                      typeParamsDef,\n                      paramsDef,\n                      payloadDef\n                    );\n                  default:\n                    return `// Not supported ${inflection.camelize(client, true)} yet.`;\n                }\n              }),\n              // 스트리밍인 경우\n              ...(api.streamOptions\n                ? [this.renderStream(api, apiBaseUrl, paramsDefAsObject)]\n                : []),\n            ].join(\"\\n\");\n          })\n          .join(\"\\n\\n\");\n\n        return `export namespace ${modelName.replace(/Model$/, \"Service\").replace(/Frame$/, \"Service\")} {\n${methodCodes}\n}`;\n      })\n      .join(\"\\n\\n\");\n\n    return {\n      lines: [body],\n      importKeys: _.difference(_.uniq(importKeys), typeParamNames),\n    };\n  }\n\n  renderAxios(\n    api: ExtendedApi,\n    apiBaseUrl: string,\n    typeParamsDef: string,\n    paramsDef: string,\n    returnTypeDef: string,\n    payloadDef: string\n  ) {\n    const methodNameAxios = api.options.resourceName\n      ? \"get\" + inflection.camelize(api.options.resourceName)\n      : api.methodName;\n\n    if (api.options.httpMethod === \"GET\") {\n      return `\nexport async function ${methodNameAxios}${typeParamsDef}(${paramsDef}): Promise<${returnTypeDef}> {\n    return fetch({\n      method: \"GET\",\n      url: \\`${apiBaseUrl}?\\${qs.stringify(${payloadDef})}\\`,\n      ${api.options.timeout ? `signal: AbortSignal.timeout(${api.options.timeout}),` : \"\"}\n    });\n}\n    `.trim();\n    } else {\n      return `\nexport async function ${methodNameAxios}${typeParamsDef}(${paramsDef}): Promise<${returnTypeDef}> {\n    return fetch({\n      method: '${api.options.httpMethod}',\n      url: \\`${apiBaseUrl}\\`,\n      data: ${payloadDef},\n      ${api.options.timeout ? `signal: AbortSignal.timeout(${api.options.timeout}),` : \"\"}\n    });\n}\n      `.trim();\n    }\n  }\n\n  renderAxiosMultipart(\n    api: ExtendedApi,\n    apiBaseUrl: string,\n    typeParamsDef: string,\n    paramsDef: string,\n    returnTypeDef: string,\n    paramsWithoutContext: ApiParam[]\n  ) {\n    const isMultiple = api.uploadOptions?.mode === \"multiple\";\n    const fileParamName = isMultiple ? \"files\" : \"file\";\n    const fileParamType = isMultiple ? \"File[]\" : \"File\";\n\n    const formDataDef = isMultiple\n      ? [\n          `${fileParamName}.forEach(f => formData.append(\"${fileParamName}\", f));`,\n          ...paramsWithoutContext.map(\n            (param) =>\n              `formData.append('${param.name}', String(${param.name}));`\n          ),\n        ].join(\"\\n\")\n      : [\n          `formData.append(\"${fileParamName}\", ${fileParamName});`,\n          ...paramsWithoutContext.map(\n            (param) =>\n              `formData.append('${param.name}', String(${param.name}));`\n          ),\n        ].join(\"\\n\");\n\n    const paramsDefComma = paramsDef !== \"\" ? \", \" : \"\";\n    return `\nexport async function ${api.methodName}${typeParamsDef}(\n  ${paramsDef}${paramsDefComma}\n  ${fileParamName}: ${fileParamType},\n  onUploadProgress?: (pe:AxiosProgressEvent) => void\n  ): Promise<${returnTypeDef}> {\n    const formData = new FormData();\n    ${formDataDef}\n    return fetch({\n      method: 'POST',\n      url: \\`${apiBaseUrl}\\`,\n      headers: {\n        \"Content-Type\": \"multipart/form-data\",\n      },\n      onUploadProgress,\n      data: formData,\n      ${api.options.timeout ? `signal: AbortSignal.timeout(${api.options.timeout}),` : \"\"}\n    });\n  }\n  `.trim();\n  }\n\n  renderSwr(\n    api: ExtendedApi,\n    apiBaseUrl: string,\n    typeParamsDef: string,\n    paramsDef: string,\n    returnTypeDef: string,\n    payloadDef: string\n  ) {\n    const methodNameSwr = api.options.resourceName\n      ? \"use\" + inflection.camelize(api.options.resourceName)\n      : \"use\" + inflection.camelize(api.methodName);\n    return `  export function ${inflection.camelize(\n      methodNameSwr,\n      true\n    )}${typeParamsDef}(${[paramsDef, \"swrOptions?: SwrOptions\"]\n      .filter((p) => p !== \"\")\n      .join(\",\")}, ): SWRResponse<${returnTypeDef}, SWRError> {\n    return useSWR(handleConditional([\n      \\`${apiBaseUrl}\\`,\n      ${payloadDef},\n    ], swrOptions?.conditional)${\n      api.options.httpMethod === \"POST\" ? \", swrPostFetcher\" : \"\"\n    }${\n      api.options.timeout ? `, { loadingTimeout: ${api.options.timeout} }` : \"\"\n    });\n  }`;\n  }\n\n  renderWindowFetch(\n    api: ExtendedApi,\n    apiBaseUrl: string,\n    typeParamsDef: string,\n    paramsDef: string,\n    payloadDef: string\n  ) {\n    return `\nexport async function ${api.methodName}${typeParamsDef}(${paramsDef}): Promise<Response> {\n    return window.fetch(\\`${apiBaseUrl}?\\${qs.stringify(${payloadDef})}\\`${\n      api.options.timeout\n        ? `, { signal: AbortSignal.timeout(${api.options.timeout}) }`\n        : \"\"\n    });\n}\n    `.trim();\n  }\n\n  renderStream(\n    api: ExtendedApi,\n    apiBaseUrl: string,\n    paramsDefAsObject: string\n  ) {\n    if (!api.streamOptions) {\n      return \"// streamOptions not found\";\n    }\n\n    const methodNameStream = api.options.resourceName\n      ? \"use\" + inflection.camelize(api.options.resourceName)\n      : \"use\" + inflection.camelize(api.methodName);\n    const methodNameStreamCamelized = inflection.camelize(\n      methodNameStream,\n      true\n    );\n\n    const eventsTypeDef = zodTypeToTsTypeDef(api.streamOptions.events);\n\n    return `  export function ${methodNameStreamCamelized}(\n  params: ${paramsDefAsObject},\n  handlers: EventHandlers<${eventsTypeDef} & { end?: () => void }>,\n  options: SSEStreamOptions) {\n    return useSSEStream<${eventsTypeDef}>(\\`${apiBaseUrl}\\`, params, handlers, options);\n  }`;\n  }\n}\n"],"names":["inflection","_","ApiParamType","apiParamTypeToTsType","apiParamToTsCode","unwrapPromiseOnce","zodTypeToTsTypeDef","apiParamToTsCodeAsObject","Template","Sonamu","Template__service","getTargetAndPath","names","target","path","fs","render","namesRecord","syncer","apis","apisForThisModel","filter","api","modelName","capital","lines","importKeys","getTypeSource","hasAxiosProgressEvent","find","options","clients","includes","body","join","key","customHeaders","typeParamNames","groups","groupBy","Object","keys","map","methods","methodCodes","paramsWithoutContext","parameters","param","isContext","type","isRefKnex","optional","name","startsWith","typeParamsDef","typeParameters","typeParam","concat","id","paramsDef","paramsDefAsObject","returnTypeDef","returnType","payloadDef","apiBaseUrl","config","route","prefix","sortBy","client","renderAxios","renderAxiosMultipart","renderSwr","renderWindowFetch","camelize","streamOptions","renderStream","replace","difference","uniq","methodNameAxios","resourceName","methodName","httpMethod","timeout","trim","isMultiple","uploadOptions","mode","fileParamName","fileParamType","formDataDef","paramsDefComma","methodNameSwr","p","methodNameStream","methodNameStreamCamelized","eventsTypeDef","events"],"mappings":"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"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"view_enums_buttonset.template.d.ts","sourceRoot":"","sources":["../../../src/template/implementations/view_enums_buttonset.template.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAiB,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAC/E,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC,qBAAa,8BAA+B,SAAQ,QAAQ;;IAK1D,gBAAgB,CAAC,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM;;;;IAO9D,MAAM,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,eAAe,CAAC,sBAAsB,CAAC;;;;;;CAiBrE"}

package/dist/template/implementations/view_enums_buttonset.template.js

@@ -0,0 +1,31 @@
+import { EntityManager } from "../../entity/entity-manager.js";
+import { Template } from "../template.js";
+export class Template__view_enums_buttonset extends Template {
+    constructor(){
+        super("view_enums_buttonset");
+    }
+    getTargetAndPath(names, componentId) {
+        return {
+            target: "web/src/components",
+            path: `${names.fs}/${componentId}ButtonSet.tsx`
+        };
+    }
+    render({ entityId, enumId }) {
+        const names = EntityManager.getNamesFromId(entityId);
+        return {
+            ...this.getTargetAndPath(names, enumId),
+            body: `
+/*
+view_enums_buttonset
+${JSON.stringify({
+                key: this.key,
+                options: entityId
+            })}
+*/
+      `.trim(),
+            importKeys: []
+        };
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,6 +1,6 @@
-import { TemplateOptions } from "../types/types";
-import { EntityNamesRecord } from "../entity/entity-manager";
-import { Template } from "./base-template";
+import { TemplateOptions } from "../../types/types";
+import { EntityNamesRecord } from "../../entity/entity-manager";
+import { Template } from "../template";
 export declare class Template__view_enums_dropdown extends Template {
     constructor();
     getTargetAndPath(names: EntityNamesRecord, enumId: string): {
@@ -14,5 +14,4 @@ export declare class Template__view_enums_dropdown extends Template {
         path: string;
     };
 }
-export declare function getLabel(entityId: string, enumId: string): string;
 //# sourceMappingURL=view_enums_dropdown.template.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"view_enums_dropdown.template.d.ts","sourceRoot":"","sources":["../../../src/template/implementations/view_enums_dropdown.template.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAiB,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAC/E,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAGvC,qBAAa,6BAA8B,SAAQ,QAAQ;;IAKzD,gBAAgB,CAAC,KAAK,EAAE,iBAAiB,EAAE,MAAM,EAAE,MAAM;;;;IAOzD,MAAM,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,eAAe,CAAC,qBAAqB,CAAC;;;;;;CAmCpE"}

package/dist/template/implementations/view_enums_dropdown.template.js

@@ -0,0 +1,50 @@
+import { EntityManager } from "../../entity/entity-manager.js";
+import { Template } from "../template.js";
+import { getLabel } from "../helpers.js";
+export class Template__view_enums_dropdown extends Template {
+    constructor(){
+        super("view_enums_dropdown");
+    }
+    getTargetAndPath(names, enumId) {
+        return {
+            target: "web/src/components",
+            path: `${names.fs}/${enumId}Dropdown.tsx`
+        };
+    }
+    render({ entityId, enumId }) {
+        const names = EntityManager.getNamesFromId(entityId);
+        const label = getLabel(entityId, enumId);
+        return {
+            ...this.getTargetAndPath(names, enumId),
+            body: `
+import React from 'react';
+import {
+  Dropdown,
+  DropdownProps,
+} from 'semantic-ui-react';
+
+import { ${enumId}Label } from 'src/services/sonamu.generated';
+
+export function ${enumId}Dropdown(props: DropdownProps) {
+  const options = Object.entries(${enumId}Label).map(([key, label]) => {
+    return {
+      key,
+      value: key,
+      text: "${label}: " + label,
+    };
+  });
+  return (
+    <Dropdown
+      className="label"
+      options={options}
+      {...props}
+    />
+  );
+}
+      `.trim(),
+            importKeys: []
+        };
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"view_enums_select.template.d.ts","sourceRoot":"","sources":["../../../src/template/implementations/view_enums_select.template.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAiB,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAC/E,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAGvC,qBAAa,2BAA4B,SAAQ,QAAQ;;IAKvD,gBAAgB,CAAC,KAAK,EAAE,iBAAiB,EAAE,MAAM,EAAE,MAAM;;;;IAOzD,MAAM,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,eAAe,CAAC,mBAAmB,CAAC;;;;;;CAwClE"}

package/dist/template/implementations/view_enums_select.template.js

@@ -0,0 +1,55 @@
+import { EntityManager } from "../../entity/entity-manager.js";
+import { Template } from "../template.js";
+import { getLabel } from "../helpers.js";
+export class Template__view_enums_select extends Template {
+    constructor(){
+        super("view_enums_select");
+    }
+    getTargetAndPath(names, enumId) {
+        return {
+            target: "web/src/components",
+            path: `${names.fs}/${enumId}Select.tsx`
+        };
+    }
+    render({ entityId, enumId }) {
+        const names = EntityManager.getNamesFromId(entityId);
+        const label = getLabel(entityId, enumId);
+        return {
+            ...this.getTargetAndPath(names, enumId),
+            body: `
+import React from 'react';
+import {
+  Dropdown,
+  DropdownProps,
+} from 'semantic-ui-react';
+
+import { ${enumId}, ${enumId}Label } from 'src/services/sonamu.generated';
+
+export type ${enumId}SelectProps = {
+  placeholder?: string;
+  textPrefix?: string;
+} & DropdownProps;
+export function ${enumId}Select({placeholder, textPrefix, ...props}: ${enumId}SelectProps) {
+  const typeOptions = ${enumId}.options.map((key) => ({
+    key,
+    value: key,
+    text: (textPrefix ?? '${label}: ') + ${enumId}Label[key],
+  }));
+
+  return (
+    <Dropdown
+      placeholder={placeholder ?? "${label}"}
+      selection
+      options={typeOptions}
+      selectOnBlur={false}
+      {...props}
+    />
+  );
+}
+      `.trim(),
+            importKeys: []
+        };
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,6 +1,6 @@
-import { RenderingNode, TemplateKey, TemplateOptions } from "../types/types";
-import { EntityNamesRecord } from "../entity/entity-manager";
-import { Template } from "./base-template";
+import { RenderingNode, TemplateKey, TemplateOptions } from "../../types/types";
+import { EntityNamesRecord } from "../../entity/entity-manager";
+import { Template } from "../template";
 export declare class Template__view_form extends Template {
     constructor();
     getTargetAndPath(names: EntityNamesRecord): {
@@ -12,7 +12,7 @@ export declare class Template__view_form extends Template {
     renderColumnImport(entityId: string, col: RenderingNode): string;
     renderColumn(entityId: string, col: RenderingNode, names: EntityNamesRecord, parent?: string): string;
     resolveDefaultValue(columns: RenderingNode[]): object;
-    render({ entityId }: TemplateOptions["view_form"], saveParamsNode: RenderingNode): {
+    render({ entityId }: TemplateOptions["view_form"]): Promise<{
         body: string;
         importKeys: never[];
         preTemplates: {
@@ -21,6 +21,6 @@ export declare class Template__view_form extends Template {
         }[];
         target: string;
         path: string;
-    };
+    }>;
 }
 //# sourceMappingURL=view_form.template.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"view_form.template.d.ts","sourceRoot":"","sources":["../../../src/template/implementations/view_form.template.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAChF,OAAO,EAAiB,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAE/E,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAKvC,qBAAa,mBAAoB,SAAQ,QAAQ;;IAK/C,gBAAgB,CAAC,KAAK,EAAE,iBAAiB;;;;IAOzC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM;IAO5C,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM;IAQ5C,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,aAAa;IAyBvD,YAAY,CACV,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,aAAa,EAClB,KAAK,EAAE,iBAAiB,EACxB,MAAM,GAAE,MAAW,GAClB,MAAM;IAqET,mBAAmB,CAAC,OAAO,EAAE,aAAa,EAAE,GAAG,MAAM;IAqC/C,MAAM,CAAC,EAAE,QAAQ,EAAE,EAAE,eAAe,CAAC,WAAW,CAAC;;;;;;;;;;CA2PxD"}