swagger-fsd-gen 1.0.0

package/templates/tanstack-query/api.ejs

@@ -0,0 +1,195 @@
+<%
+/** 
+* @description Tanstack Query - Query 생성 템플릿 입니다.
+*/
+
+const { utils, route, modelTypes, config } = it;
+const { pascalCase, internalCase: camelCase, _: lodash } = utils;
+const { moduleName, routes } = route;
+
+// 유틸리티 함수들
+const removeBracket = (type) => type.replace(/[()]/g, '');
+
+const cleanupType = (type) => {
+    return type
+      // 배열 타입 주변의 불필요한 괄호 제거
+      .replace(/\(([A-Za-z0-9_]+)\)(\[\])/g, '$1$2')
+      
+      // 속성 뒤의 불필요한 공백 제거 (콤마 앞의 공백 제거)
+      .replace(/\s+,/g, ',')
+      
+      // 배열 타입 뒤의 콤마와 공백 제거
+      .replace(/(\[\]),\s*/g, '$1')
+      
+      // 객체 끝의 불필요한 공백 제거
+      .replace(/\s+}/g, '}')
+      
+      // 객체 시작의 불필요한 공백 제거
+      .replace(/{\s+/g, '{')
+      
+      // 연속된 공백 제거
+      .replace(/\s{2,}/g, ' ');
+  };
+
+// 경로 관련 함수들
+const getFunctionName = ({ request: { method, path } }) => {
+  const segments = path.split('/').map(segment => {
+    if (segment.includes('${')) {
+      return `By_${segment.replace(/[${}]/g, '')}`;
+    }
+    return segment;
+  });
+  
+  return `${method}${pascalCase(segments.join('_'))}`;
+};
+
+const buildQueryKey = ({ path }) => {
+  return path
+    .split('/')
+    .filter(segment => segment && segment !== 'api')
+    .map(segment => {
+      if (segment.match(/\${/)) {
+        return segment.replace(/[${}]/g, '').toUpperCase().replace(/-/g, '_');
+      }
+      return segment.toUpperCase().replace(/-/g, '_');
+    })
+    .join('_');
+};
+
+const buildPathQueryKey = ({ path }) => {
+  return path
+    .split('/')
+    .filter(segment => segment && segment !== 'api')
+    .map(segment => {
+      if (segment.match(/\${/)) {
+        return segment.replace(/[${}]/g, '').replace(/-/g, '_');
+      }
+      return `'${segment.replace(/-/g, '_')}'`;
+    });
+};
+
+// 요청 파라미터 생성 함수
+const getRequestParams = ({ parameters = [], query, payload, routeName }) => {
+  const queryParamsDto = query ? `${pascalCase(routeName.usage)}QueryParams` : '';
+
+  const paramsWithTypes = lodash.compact([
+    ...parameters.map(({ name, type, optional }) => 
+      `${name}${optional ? '?' : ''}: ${removeBracket(type)}`
+    ),
+    queryParamsDto ? `params${query.optional ? '?' : ''}: ${queryParamsDto}` : '',
+    payload ? `body${payload.optional ? '?' : ''}: ${removeBracket(payload.type)}` : '',
+  ]).join(', ');
+
+  const paramsWithoutTypes = lodash.compact([
+    ...parameters.map(({ name, optional }) => `${name}${optional ? '?' : ''}`),
+    query ? 'params' : '',
+    payload ? 'body' : '',
+  ]).join(', ');
+
+  return {
+    withTypes: paramsWithTypes,
+    withoutTypes: paramsWithoutTypes
+  };
+};
+
+// 쿼리 설정 생성
+const queryConfigs = routes
+  .filter(({ request: { method } }) => method === 'get')
+  .map(route => {
+    const functionName = getFunctionName(route);
+    const { request, response } = route;
+    const queryKeyName = buildQueryKey(request);
+    const pathQueryKey = buildPathQueryKey(request);
+    
+    const { withTypes: requestParams, withoutTypes: requestParamsWithoutTypes } = 
+      getRequestParams({
+        ...request,
+        routeName: route.routeName
+      });
+
+    const queryKeyParams = [
+      ...pathQueryKey,
+      request.query ? 'params' : null,
+      request.payload ? 'data' : null,
+    ].filter(Boolean).join(', ');
+
+    return {
+      moduleName,
+      route,
+      functionName: camelCase(functionName),
+      hookName: camelCase(`use${pascalCase(functionName)}Query`),
+      suspenseHookName: camelCase(`use${pascalCase(functionName)}SuspenseQuery`),
+      responseDto: cleanupType(response.type),
+      requestParams,
+      requestParamsWithoutTypes,
+      queryKeyName: `GET_${queryKeyName}`,
+      queryKey: `(${requestParams}) => [${queryKeyParams}]`,
+    };
+  });
+%>
+
+<% if (queryConfigs?.length) { %>
+import type {
+  DefaultError,
+  UseQueryOptions,
+  UseSuspenseQueryOptions,
+} from '@tanstack/react-query';
+import { useQuery, useSuspenseQuery } from '@tanstack/react-query';
+
+<%~ includeFile('../dto-import.ejs', { ...it }) %>
+
+import { <%~ moduleName %>Api } from './instance';
+
+export const <% ~moduleName.toUpperCase() %>_QUERY_KEY = {
+<% for (const queryConfig of queryConfigs) { %>
+  <% ~queryConfig.queryKeyName %>: <% ~queryConfig.queryKey %>,
+<% } %>
+}
+
+const queries = {
+<% for (const queryConfig of queryConfigs) { %>
+  <% ~queryConfig.functionName %>: (<% ~queryConfig.requestParams %>) => ({
+    queryKey: <% ~moduleName.toUpperCase() %>_QUERY_KEY.<% ~queryConfig.queryKeyName %>(<% ~queryConfig.requestParamsWithoutTypes %>),
+    queryFn: () => <% ~moduleName %>Api.<% ~queryConfig.functionName %>(<% ~queryConfig.requestParamsWithoutTypes %>)
+  }),
+<% } %>
+}
+
+// ---------------------- Query ------------------------------
+<% for (const queryConfig of queryConfigs) {
+  const routeDocs = includeFile("../route-docs.ejs", { config, route: queryConfig.route, utils });
+%>
+/**
+<%~ routeDocs.lines %>
+ */
+export const <%~ queryConfig.hookName %> = <TData = <%~ queryConfig.responseDto %>>(
+  <%~ queryConfig.requestParams ? `${queryConfig.requestParams},`:''%>
+  options?: Omit<UseQueryOptions<<%~ queryConfig.responseDto %>, DefaultError, TData>, 'queryKey' | 'queryFn'>
+) => {
+  return useQuery({
+    ...queries.<% ~queryConfig.functionName %>(<% ~queryConfig.requestParamsWithoutTypes %>),
+    ...options,
+  });
+}
+
+<% } %>
+
+// ------------------ Suspense Query --------------------------
+<% for (const queryConfig of queryConfigs) {
+  const routeDocs = includeFile("../route-docs.ejs", { config, route: queryConfig.route, utils });
+%>
+/**
+<%~ routeDocs.lines %>
+ */
+export const <%~ queryConfig.suspenseHookName %> = <TData = <%~ queryConfig.responseDto %>>(
+  <%~ queryConfig.requestParams ? `${queryConfig.requestParams},`:''%>
+  options?: Omit<UseSuspenseQueryOptions<<%~ queryConfig.responseDto %>, DefaultError, TData>, 'queryKey' | 'queryFn'>
+) => {
+  return useSuspenseQuery({
+    ...queries.<% ~queryConfig.functionName %>(<% ~queryConfig.requestParamsWithoutTypes %>),
+    ...options,
+  });
+}
+
+<% } %>
+<% } %>

package/templates/tanstack-query/route-types.ejs

@@ -0,0 +1,152 @@
+<%
+/** 
+* @description Tanstack Query - Mutation 생성 템플릿 입니다.
+*/
+
+const { utils, route, modelTypes, config } = it;
+const { pascalCase, internalCase: camelCase } = utils;
+const { moduleName, routes } = route;
+
+const getFunctionName = ({ request: { method, path } }) =>
+        `${method}${pascalCase(path
+                .split('/')
+                .map(segment =>
+                        segment.includes('${')
+                                ? `By_${segment.replace(/[${}]/g, '')}`
+                                : segment
+                )
+                .join('_'))}`;
+
+const removeBracket = (type) => type.replace(/[()]/g, '')
+
+const getRequestParams = ({ parameters = [], query, payload, routeName }) => {
+    const queryParamsDto = query ? `${pascalCase(routeName.usage)}QueryParams` : '';
+
+    return {
+        withTypes: [
+            ...parameters.map(({ name, type, optional }) => `${name}${optional ? '?' : ''}: ${removeBracket(type)}`),
+            queryParamsDto ? `params${query.optional ? '?' : ''}: ${queryParamsDto}` : '',
+            payload ? `body${payload.optional ? '?' : ''}: ${removeBracket(payload.type)}` : '',
+        ].filter(Boolean).join(', '),
+        withoutTypes: [
+            ...parameters.map(({ name, optional }) => `${name}${optional ? '?' : ''}`),
+            query ? `params` : '',
+            payload ? 'body' : '',
+        ].filter(Boolean).join(', ')
+    } };
+
+const buildMutationKeyName = ({ path, method }) =>
+        method.toUpperCase()+'_'+path
+               .split('/')
+               .filter(segment => segment )
+               .map(segment =>
+                       segment.match(/\${/)
+                               ? segment.replace(/[${}]/g, '').toUpperCase()
+                               : segment.toUpperCase()
+               )
+               .join('_')
+
+const buildPathMutationKey = ({ path }) =>
+        path
+                .split('/')
+                .filter(segment => segment)
+                .map(segment =>
+                        `'${segment.replace(/[${}]/g, '')}'`)
+
+const mutationConfigs = routes
+        .filter(({ request: { method } }) => method === 'post' || method === 'patch' || method === 'put' || method === 'delete')
+        .map(route => {
+            const functionName = getFunctionName(route);
+            const { request, response } = route;
+            const mutationKeyName = buildMutationKeyName(request);
+            const mutationKey = buildPathMutationKey(request);
+            const { withTypes: requestParams, withoutTypes: requestParamsWithoutTypes } = getRequestParams({
+                ...request,
+                routeName: route.routeName
+            });
+
+            return {
+                moduleName,
+                route,
+                functionName: camelCase(functionName),
+                hookName: `use${pascalCase(functionName)}Mutation`,
+                responseDto: removeBracket(response.type),
+                hasVariables: requestParams.length > 0,
+                requestParams,
+                requestParamsWithoutTypes,
+                mutationKeyName,
+                mutationKey: `[${mutationKey.filter(Boolean).join(', ')}]`,
+            };
+        });
+
+if (mutationConfigs.length > 0) {
+    const variableTypes = mutationConfigs
+            .filter(config => config.hasVariables)
+            .map(config => {
+                const headerName = config.route.specificArgs.headers ? `${pascalCase(config.route.routeName.usage)}Headers` : null;
+                return `type T${pascalCase(config.functionName)}Variables = { ${config.requestParams}, kyInstance?: KyInstance; options?: ${headerName ? `Omit<Options, 'headers'> & { headers: ${headerName} }` : 'Options'}; };`
+            })
+            .join('\n');
+
+%>
+
+<% if (mutationConfigs?.length) { %>
+
+import type {
+DefaultError,
+UseMutationOptions,
+useQueryClient,
+} from '@tanstack/react-query';
+import { useMutation } from '@tanstack/react-query';
+import type{ KyInstance, Options } from 'ky';
+
+<%~ includeFile('../dto-import.ejs', { ...it }) %>
+
+import { <%= moduleName %>Api } from './instance';
+
+export const <% ~moduleName.toUpperCase() %>_MUTATION_KEY = {
+<% for (const config of mutationConfigs) { %>
+    <% ~config.mutationKeyName %>: <% ~config.mutationKey %>,
+<% } %>
+};
+
+const mutations = {
+<% for (const config of mutationConfigs) { %>
+    <%= config.functionName %>: () => ({
+    mutationFn: <% if (config.hasVariables) { %>(variables: T<%= pascalCase(config.functionName) %>Variables) => {
+    const { <%= config.requestParamsWithoutTypes %>, kyInstance, options } = variables;
+    return <%= moduleName %>Api.<%= config.functionName %>(<%= config.requestParamsWithoutTypes %>, kyInstance, options);
+    }<% } else { %>() => <%= moduleName %>Api.<%= config.functionName %>()<% } %>,
+    mutationKey: <% ~moduleName.toUpperCase() %>_MUTATION_KEY.<% ~config.mutationKeyName %>,
+    }),
+<% } %>
+};
+
+<% for (const mutationConfig of mutationConfigs) {
+    const routeDocs = includeFile("../route-docs.ejs", { config, route: mutationConfig.route, utils });
+%>
+
+/**
+<%~ routeDocs.lines %>
+ */
+export const <%= mutationConfig.hookName %> = (
+options?: Omit<
+UseMutationOptions<<%= mutationConfig.responseDto %>, DefaultError, <%= mutationConfig.hasVariables ? `T${pascalCase(mutationConfig.functionName)}Variables` : 'void' %>>,
+'mutationFn'|'mutationKey'
+>
+) => {
+return useMutation({
+...mutations.<%= mutationConfig.functionName %>(),
+...options,
+});
+};
+
+<% } %>
+
+<%~ variableTypes %>
+
+<%
+} else { %>
+    <% /* mutationConfigs가 비어있을 때는 아무것도 출력되지 않습니다 */ %>
+<% } %>
+<% } %>

package/utils/fetch-swagger.js

@@ -0,0 +1,46 @@
+/**
+ * Swagger 문서 가져오기 유틸리티
+ * - 원격 Swagger 문서를 HTTP 요청으로 가져옴
+ * - HTTP Basic Authentication 지원
+ * - JSON 형태의 Swagger 문서 반환
+ *
+ * @param {string} url - Swagger 문서 URL
+ * @param {string} username - HTTP Basic Auth 사용자명 (선택사항)
+ * @param {string} password - HTTP Basic Auth 비밀번호 (선택사항)
+ * @returns {Promise<Object>} Swagger 문서 JSON 객체
+ *
+ * @example
+ * // 인증 없이 가져오기
+ * const swagger = await fetchSwagger('https://api.example.com/swagger.json');
+ *
+ * // 인증과 함께 가져오기
+ * const swagger = await fetchSwagger(
+ *   'https://api.example.com/swagger.json',
+ *   'admin',
+ *   'password'
+ * );
+ */
+export const fetchSwagger = async (url, username, password) => {
+  // HTTP Basic Authentication 헤더 생성
+  const credentials = btoa(`${username}:${password}`);
+
+  try {
+    // Swagger 문서 HTTP 요청
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        Authorization: `Basic ${credentials}`,
+      },
+    });
+
+    // HTTP 응답 상태 확인
+    if (!response.ok) {
+      console.error("failed with status code", response.status);
+    }
+
+    // JSON 형태로 파싱하여 반환
+    return response.json();
+  } catch (error) {
+    console.error("There was a problem with the fetch operation:", error);
+  }
+};

package/utils/file.js

@@ -0,0 +1,81 @@
+/**
+ * 파일 처리 유틸리티 모듈
+ * - 파일 및 디렉토리 생성 기능
+ * - 생성된 API 파일들을 적절한 위치에 저장
+ * - 디렉토리 자동 생성 지원
+ */
+
+import path from "node:path";
+import fs from "node:fs";
+
+/**
+ * 지정된 경로에 파일을 생성하는 함수
+ * - 필요한 디렉토리를 자동으로 생성
+ * - 파일 내용을 UTF-8 인코딩으로 저장
+ * - 성공/실패 로그 출력
+ *
+ * @param {string} filePath - 생성할 파일의 전체 경로
+ * @param {string} fileContent - 파일에 저장할 내용
+ *
+ * @example
+ * await writeFileToPath('./src/api/user.ts', 'export class UserApi {}');
+ */
+export const writeFileToPath = async (filePath, fileContent) => {
+  // 파일 경로에서 디렉토리 경로 추출
+  const outputDir = path.dirname(filePath);
+
+  try {
+    // 디렉토리가 존재하지 않으면 재귀적으로 생성
+    await fs.promises.mkdir(outputDir, { recursive: true });
+
+    // 파일 내용을 UTF-8 인코딩으로 저장
+    await fs.promises.writeFile(filePath, fileContent);
+
+    console.log(`✅  Successfully wrote file at ${filePath}`);
+  } catch (err) {
+    console.error(`☠️   Failed to write file at ${filePath}: ${err}`);
+  }
+};
+
+/**
+ * DTO 파일을 저장하는 함수
+ * - 생성된 파일들 중에서 data-contracts 파일을 찾아 저장
+ * - DTO 타입 정의들이 포함된 파일
+ *
+ * @param {string} outputPath - DTO 파일을 저장할 경로
+ * @param {Array} generateFiles - 생성된 파일들의 배열
+ *
+ * @deprecated 현재는 generate-all.js에서 직접 처리하므로 사용되지 않음
+ */
+export const saveDto = async (outputPath, generateFiles) => {
+  await writeFileToPath(
+    outputPath,
+    generateFiles.find(({ fileName }) => fileName === "data-contracts")
+      .fileContent
+  );
+};
+
+/**
+ * 엔티티별 API 파일들을 저장하는 함수
+ * - http-client와 data-contracts를 제외한 모든 파일 저장
+ * - 모듈명을 기반으로 경로 동적 생성
+ *
+ * @param {string} outputPath - 출력 경로 템플릿 ({moduleName} 플레이스홀더 포함)
+ * @param {Array} generateFiles - 생성된 파일들의 배열
+ *
+ * @deprecated 현재는 generate-all.js에서 직접 처리하므로 사용되지 않음
+ */
+export const saveEntitiesFile = async (outputPath, generateFiles) => {
+  for (const { fileName, fileContent } of generateFiles) {
+    // http-client와 data-contracts 파일은 제외
+    if (fileName === "http-client" || fileName === "data-contracts") continue;
+
+    // 파일명을 소문자로 변환하여 모듈명으로 사용
+    const moduleName = fileName.toLowerCase();
+
+    // 출력 경로에서 {moduleName} 플레이스홀더를 실제 모듈명으로 교체
+    const output = outputPath.replace("{moduleName}", moduleName);
+
+    await writeFileToPath(output, fileContent);
+  }
+};

package/utils/parser.js

@@ -0,0 +1,111 @@
+/**
+ * Swagger 스키마 파서 유틸리티
+ * - Swagger anyOf 스키마를 TypeScript Union 타입으로 변환
+ * - 필수/선택적 필드 처리
+ * - null 타입 자동 추가/제거
+ */
+
+/**
+ * 기본 스키마 파서 클래스
+ * - swagger-typescript-api의 스키마 파서 기반 클래스
+ * - 다양한 스키마 타입 처리를 위한 공통 기능 제공
+ */
+class MonoSchemaParser {
+  schema;
+  typeName;
+  schemaPath;
+
+  schemaParser;
+  /** @type {SchemaParserFabric} */
+  schemaParserFabric;
+  /** @type {TypeNameFormatter} */
+  typeNameFormatter;
+  /** @type {SchemaComponentsMap} */
+  schemaComponentsMap;
+  /** @type {SchemaUtils} */
+  schemaUtils;
+  /** @type {CodeGenConfig} */
+  config;
+  /** @type {SchemaFormatters} */
+  schemaFormatters;
+
+  /**
+   * MonoSchemaParser 생성자
+   * @param {Object} schemaParser - 상위 스키마 파서 인스턴스
+   * @param {Object} schema - 파싱할 스키마 객체
+   * @param {string} typeName - 생성할 타입명
+   * @param {Array} schemaPath - 스키마 경로 배열 (기본값: [])
+   */
+  constructor(schemaParser, schema, typeName, schemaPath = []) {
+    this.schemaParser = schemaParser;
+    this.schemaParserFabric = schemaParser.schemaParserFabric;
+    this.schema = schema;
+    this.typeName = typeName;
+    this.typeNameFormatter = schemaParser.typeNameFormatter;
+    this.schemaPath = schemaPath;
+    this.schemaComponentsMap = this.schemaParser.schemaComponentsMap;
+    this.schemaUtils = this.schemaParser.schemaUtils;
+    this.config = this.schemaParser.config;
+    this.schemaFormatters = this.schemaParser.schemaFormatters;
+  }
+}
+
+/**
+ * anyOf 스키마 파서 클래스
+ * - Swagger anyOf 스키마를 TypeScript Union 타입 (T1 | T2)으로 변환
+ * - 필수/선택적 필드에 따른 null 타입 자동 처리
+ * - 중복 타입 제거 및 최적화
+ *
+ * @example
+ * // Swagger anyOf 스키마:
+ * {
+ *   "anyOf": [
+ *     { "type": "string" },
+ *     { "type": "number" }
+ *   ]
+ * }
+ *
+ * // 생성되는 TypeScript 타입:
+ * string | number
+ */
+class AnyOfSchemaParser extends MonoSchemaParser {
+  /**
+   * anyOf 스키마를 TypeScript Union 타입으로 파싱
+   * @returns {string} TypeScript Union 타입 문자열
+   */
+  parse() {
+    // 제외할 타입들 (any 타입은 항상 제외)
+    const ignoreTypes = [this.config.Ts.Keyword.Any];
+
+    // 필수 필드 여부에 따른 null 타입 처리
+    if (this.schema.required === "boolean") {
+      // 스키마에 required가 boolean으로 명시된 경우
+      !this.schema.required && ignoreTypes.push("null");
+    } else {
+      // 상위 스키마에서 required 필드 확인
+      const isRequired = this.schemaComponentsMap._data
+        .find((v) => v.typeName === this.schemaPath.at(0))
+        ?.rawTypeData?.required?.includes(this.schemaPath.at(1));
+      !isRequired && ignoreTypes.push("null");
+    }
+
+    // anyOf 배열의 각 스키마를 TypeScript 타입으로 변환
+    const combined = this.schema.anyOf.map((childSchema) =>
+      this.schemaParserFabric.getInlineParseContent(
+        this.schemaUtils.makeAddRequiredToChildSchema(this.schema, childSchema),
+        this.schemaPath
+      )
+    );
+
+    // 제외할 타입들을 필터링하여 최종 타입 배열 생성
+    const filtered = this.schemaUtils.filterSchemaContents(
+      combined,
+      (content) => !ignoreTypes.includes(content)
+    );
+
+    // TypeScript Union 타입 문자열 생성 (예: "string | number")
+    return this.config.Ts.UnionType(filtered);
+  }
+}
+
+export { AnyOfSchemaParser };

package/utils/string.js

@@ -0,0 +1,33 @@
+/**
+ * 문자열 처리 유틸리티 모듈
+ * - 문자열 케이스 변환 기능
+ * - 파일명 생성을 위한 kebab-case 변환
+ */
+
+/**
+ * 문자열을 kebab-case로 변환하는 함수
+ * - PascalCase, camelCase, snake_case를 kebab-case로 변환
+ * - 공백을 하이픈으로 변환
+ * - 모든 문자를 소문자로 변환
+ *
+ * @param {string} str - 변환할 문자열
+ * @returns {string} kebab-case로 변환된 문자열
+ *
+ * @example
+ * toKebabCase('MyApiTitle') // 'my-api-title'
+ * toKebabCase('user_management') // 'user-management'
+ * toKebabCase('API Documentation') // 'api-documentation'
+ */
+export const toKebabCase = (str) => {
+  return (
+    str
+      // PascalCase/camelCase를 kebab-case로 변환 (예: MyApi -> My-Api)
+      .replace(/([a-z])([A-Z])/g, "$1-$2")
+      // 공백을 하이픈으로 변환
+      .replace(/\s+/g, "-")
+      // 언더스코어를 하이픈으로 변환
+      .replace(/_/g, "-")
+      // 모든 문자를 소문자로 변환
+      .toLowerCase()
+  );
+};

package/utils/url.js

@@ -0,0 +1,34 @@
+/**
+ * URL 처리 유틸리티 모듈
+ * - URL 유효성 검증 기능
+ * - 로컬 파일과 원격 URL 구분
+ */
+
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+
+/**
+ * 문자열이 유효한 URL인지 확인하는 함수
+ * - HTTP/HTTPS URL 형식 검증
+ * - 로컬 파일 경로와 원격 URL 구분에 사용
+ *
+ * @param {string} string - 검증할 문자열
+ * @returns {boolean} 유효한 URL이면 true, 아니면 false
+ *
+ * @example
+ * isUrl('https://api.example.com/swagger.json') // true
+ * isUrl('./swagger.yml') // false
+ * isUrl('not-a-url') // false
+ */
+export const isUrl = (string) => {
+  try {
+    // URL 생성자를 사용하여 유효성 검증
+    // 유효하지 않은 URL이면 예외 발생
+    new URL(string);
+    return true;
+  } catch (err) {
+    // URL 생성 실패 시 false 반환
+    return false;
+  }
+};