@skmtc/core 0.0.792 → 0.0.794

package/esm/typescript/toPathParams.d.ts

@@ -1,2 +1,181 @@
+/**
+ * Converts OpenAPI path parameters to React Router path parameter syntax.
+ *
+ * This utility function transforms OpenAPI path syntax (using curly braces) into
+ * React Router path parameter syntax (using colon prefix). It's essential for
+ * generating React Router route definitions and other routing configurations
+ * that need to match URL parameters.
+ *
+ * The function performs a simple but crucial transformation that enables
+ * OpenAPI-defined paths to be used directly in React Router route definitions,
+ * maintaining the same parameter names while adapting the syntax.
+ *
+ * @param path - OpenAPI path string with {parameter} syntax
+ * @returns React Router path string with :parameter syntax
+ *
+ * @example Basic path parameter conversion
+ * ```typescript
+ * import { toPathParams } from '@skmtc/core';
+ *
+ * const routePath = toPathParams('/users/{id}/posts/{postId}');
+ * console.log(routePath); // '/users/:id/posts/:postId'
+ * ```
+ *
+ * @example React Router route generation
+ * ```typescript
+ * import { Routes, Route } from 'react-router-dom';
+ *
+ * const apiPaths = [
+ *   '/users/{id}',
+ *   '/users/{id}/posts/{postId}',
+ *   '/organizations/{orgId}/members/{userId}'
+ * ];
+ *
+ * const routePaths = apiPaths.map(toPathParams);
+ * // [
+ * //   '/users/:id',
+ * //   '/users/:id/posts/:postId',
+ * //   '/organizations/:orgId/members/:userId'
+ * // ]
+ *
+ * function App() {
+ *   return (
+ *     <Routes>
+ *       {routePaths.map(path => (
+ *         <Route key={path} path={path} element={<DetailView />} />
+ *       ))}
+ *     </Routes>
+ *   );
+ * }
+ * ```
+ *
+ * @example Express.js route generation
+ * ```typescript
+ * import express from 'express';
+ *
+ * class RouteGenerator {
+ *   generateExpressRoutes(openApiPaths: string[]) {
+ *     const router = express.Router();
+ *
+ *     openApiPaths.forEach(path => {
+ *       const expressPath = toPathParams(path);
+ *
+ *       router.get(expressPath, (req, res) => {
+ *         // Handler logic using req.params
+ *         res.json({ path: expressPath, params: req.params });
+ *       });
+ *     });
+ *
+ *     return router;
+ *   }
+ * }
+ *
+ * const generator = new RouteGenerator();
+ * const router = generator.generateExpressRoutes([
+ *   '/api/users/{userId}',
+ *   '/api/users/{userId}/orders/{orderId}'
+ * ]);
+ * // Generates routes for:
+ * // '/api/users/:userId'
+ * // '/api/users/:userId/orders/:orderId'
+ * ```
+ *
+ * @example Route configuration generation
+ * ```typescript
+ * interface RouteConfig {
+ *   path: string;
+ *   component: string;
+ *   exact?: boolean;
+ * }
+ *
+ * function generateRouteConfigs(apiEndpoints: Array<{path: string, component: string}>): RouteConfig[] {
+ *   return apiEndpoints.map(endpoint => ({
+ *     path: toPathParams(endpoint.path),
+ *     component: endpoint.component,
+ *     exact: true
+ *   }));
+ * }
+ *
+ * const routeConfigs = generateRouteConfigs([
+ *   { path: '/users/{id}', component: 'UserDetail' },
+ *   { path: '/users/{id}/settings', component: 'UserSettings' },
+ *   { path: '/projects/{projectId}/tasks/{taskId}', component: 'TaskDetail' }
+ * ]);
+ *
+ * console.log(routeConfigs);
+ * // [
+ * //   { path: '/users/:id', component: 'UserDetail', exact: true },
+ * //   { path: '/users/:id/settings', component: 'UserSettings', exact: true },
+ * //   { path: '/projects/:projectId/tasks/:taskId', component: 'TaskDetail', exact: true }
+ * // ]
+ * ```
+ *
+ * @example Next.js dynamic route generation
+ * ```typescript
+ * class NextJsRouteGenerator {
+ *   generateFileStructure(openApiPaths: string[]) {
+ *     return openApiPaths.map(path => {
+ *       // Convert to Next.js file-based routing syntax
+ *       const routerPath = toPathParams(path);
+ *       const fileName = routerPath
+ *         .replace(/:/g, '[') // :id becomes [id
+ *         .replace(/\/\[([^\]]+)/g, '/[$1]') // [id becomes [id]
+ *         .replace(/^\//,'') // Remove leading slash
+ *         + '.tsx';
+ *
+ *       return {
+ *         originalPath: path,
+ *         routerPath,
+ *         fileName
+ *       };
+ *     });
+ *   }
+ * }
+ *
+ * const generator = new NextJsRouteGenerator();
+ * const structure = generator.generateFileStructure([
+ *   '/users/{id}',
+ *   '/posts/{slug}/comments/{commentId}'
+ * ]);
+ *
+ * console.log(structure);
+ * // [
+ * //   {
+ * //     originalPath: '/users/{id}',
+ * //     routerPath: '/users/:id',
+ * //     fileName: 'users/[id].tsx'
+ * //   },
+ * //   {
+ * //     originalPath: '/posts/{slug}/comments/{commentId}',
+ * //     routerPath: '/posts/:slug/comments/:commentId',
+ * //     fileName: 'posts/[slug]/comments/[commentId].tsx'
+ * //   }
+ * // ]
+ * ```
+ *
+ * @example Integration with path matching
+ * ```typescript
+ * import { matchPath } from 'react-router-dom';
+ *
+ * class PathMatcher {
+ *   createMatcher(openApiPath: string) {
+ *     const routerPath = toPathParams(openApiPath);
+ *
+ *     return (pathname: string) => {
+ *       return matchPath(
+ *         { path: routerPath, exact: true },
+ *         pathname
+ *       );
+ *     };
+ *   }
+ * }
+ *
+ * const matcher = new PathMatcher();
+ * const userMatcher = matcher.createMatcher('/users/{id}');
+ *
+ * const match = userMatcher('/users/123');
+ * console.log(match?.params); // { id: '123' }
+ * ```
+ */
 export declare const toPathParams: (path: string) => string;
 //# sourceMappingURL=toPathParams.d.ts.map

package/esm/typescript/toPathParams.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toPathParams.d.ts","sourceRoot":"","sources":["../../src/typescript/toPathParams.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY,GAAI,MAAM,MAAM,KAAG,MAE3C,CAAA"}
+{"version":3,"file":"toPathParams.d.ts","sourceRoot":"","sources":["../../src/typescript/toPathParams.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkLG;AACH,eAAO,MAAM,YAAY,GAAI,MAAM,MAAM,KAAG,MAE3C,CAAA"}

package/esm/typescript/toPathParams.js

@@ -1,3 +1,182 @@
+/**
+ * Converts OpenAPI path parameters to React Router path parameter syntax.
+ *
+ * This utility function transforms OpenAPI path syntax (using curly braces) into
+ * React Router path parameter syntax (using colon prefix). It's essential for
+ * generating React Router route definitions and other routing configurations
+ * that need to match URL parameters.
+ *
+ * The function performs a simple but crucial transformation that enables
+ * OpenAPI-defined paths to be used directly in React Router route definitions,
+ * maintaining the same parameter names while adapting the syntax.
+ *
+ * @param path - OpenAPI path string with {parameter} syntax
+ * @returns React Router path string with :parameter syntax
+ *
+ * @example Basic path parameter conversion
+ * ```typescript
+ * import { toPathParams } from '@skmtc/core';
+ *
+ * const routePath = toPathParams('/users/{id}/posts/{postId}');
+ * console.log(routePath); // '/users/:id/posts/:postId'
+ * ```
+ *
+ * @example React Router route generation
+ * ```typescript
+ * import { Routes, Route } from 'react-router-dom';
+ *
+ * const apiPaths = [
+ *   '/users/{id}',
+ *   '/users/{id}/posts/{postId}',
+ *   '/organizations/{orgId}/members/{userId}'
+ * ];
+ *
+ * const routePaths = apiPaths.map(toPathParams);
+ * // [
+ * //   '/users/:id',
+ * //   '/users/:id/posts/:postId',
+ * //   '/organizations/:orgId/members/:userId'
+ * // ]
+ *
+ * function App() {
+ *   return (
+ *     <Routes>
+ *       {routePaths.map(path => (
+ *         <Route key={path} path={path} element={<DetailView />} />
+ *       ))}
+ *     </Routes>
+ *   );
+ * }
+ * ```
+ *
+ * @example Express.js route generation
+ * ```typescript
+ * import express from 'express';
+ *
+ * class RouteGenerator {
+ *   generateExpressRoutes(openApiPaths: string[]) {
+ *     const router = express.Router();
+ *
+ *     openApiPaths.forEach(path => {
+ *       const expressPath = toPathParams(path);
+ *
+ *       router.get(expressPath, (req, res) => {
+ *         // Handler logic using req.params
+ *         res.json({ path: expressPath, params: req.params });
+ *       });
+ *     });
+ *
+ *     return router;
+ *   }
+ * }
+ *
+ * const generator = new RouteGenerator();
+ * const router = generator.generateExpressRoutes([
+ *   '/api/users/{userId}',
+ *   '/api/users/{userId}/orders/{orderId}'
+ * ]);
+ * // Generates routes for:
+ * // '/api/users/:userId'
+ * // '/api/users/:userId/orders/:orderId'
+ * ```
+ *
+ * @example Route configuration generation
+ * ```typescript
+ * interface RouteConfig {
+ *   path: string;
+ *   component: string;
+ *   exact?: boolean;
+ * }
+ *
+ * function generateRouteConfigs(apiEndpoints: Array<{path: string, component: string}>): RouteConfig[] {
+ *   return apiEndpoints.map(endpoint => ({
+ *     path: toPathParams(endpoint.path),
+ *     component: endpoint.component,
+ *     exact: true
+ *   }));
+ * }
+ *
+ * const routeConfigs = generateRouteConfigs([
+ *   { path: '/users/{id}', component: 'UserDetail' },
+ *   { path: '/users/{id}/settings', component: 'UserSettings' },
+ *   { path: '/projects/{projectId}/tasks/{taskId}', component: 'TaskDetail' }
+ * ]);
+ *
+ * console.log(routeConfigs);
+ * // [
+ * //   { path: '/users/:id', component: 'UserDetail', exact: true },
+ * //   { path: '/users/:id/settings', component: 'UserSettings', exact: true },
+ * //   { path: '/projects/:projectId/tasks/:taskId', component: 'TaskDetail', exact: true }
+ * // ]
+ * ```
+ *
+ * @example Next.js dynamic route generation
+ * ```typescript
+ * class NextJsRouteGenerator {
+ *   generateFileStructure(openApiPaths: string[]) {
+ *     return openApiPaths.map(path => {
+ *       // Convert to Next.js file-based routing syntax
+ *       const routerPath = toPathParams(path);
+ *       const fileName = routerPath
+ *         .replace(/:/g, '[') // :id becomes [id
+ *         .replace(/\/\[([^\]]+)/g, '/[$1]') // [id becomes [id]
+ *         .replace(/^\//,'') // Remove leading slash
+ *         + '.tsx';
+ *
+ *       return {
+ *         originalPath: path,
+ *         routerPath,
+ *         fileName
+ *       };
+ *     });
+ *   }
+ * }
+ *
+ * const generator = new NextJsRouteGenerator();
+ * const structure = generator.generateFileStructure([
+ *   '/users/{id}',
+ *   '/posts/{slug}/comments/{commentId}'
+ * ]);
+ *
+ * console.log(structure);
+ * // [
+ * //   {
+ * //     originalPath: '/users/{id}',
+ * //     routerPath: '/users/:id',
+ * //     fileName: 'users/[id].tsx'
+ * //   },
+ * //   {
+ * //     originalPath: '/posts/{slug}/comments/{commentId}',
+ * //     routerPath: '/posts/:slug/comments/:commentId',
+ * //     fileName: 'posts/[slug]/comments/[commentId].tsx'
+ * //   }
+ * // ]
+ * ```
+ *
+ * @example Integration with path matching
+ * ```typescript
+ * import { matchPath } from 'react-router-dom';
+ *
+ * class PathMatcher {
+ *   createMatcher(openApiPath: string) {
+ *     const routerPath = toPathParams(openApiPath);
+ *
+ *     return (pathname: string) => {
+ *       return matchPath(
+ *         { path: routerPath, exact: true },
+ *         pathname
+ *       );
+ *     };
+ *   }
+ * }
+ *
+ * const matcher = new PathMatcher();
+ * const userMatcher = matcher.createMatcher('/users/{id}');
+ *
+ * const match = userMatcher('/users/123');
+ * console.log(match?.params); // { id: '123' }
+ * ```
+ */
 export const toPathParams = (path) => {
     return `${path.replaceAll(/{([^}]*)}/g, ':$1')}`;
 };

package/esm/typescript/toPathTemplate.d.ts

@@ -1,2 +1,116 @@
+/**
+ * Converts OpenAPI path parameters into JavaScript template literal syntax.
+ *
+ * This utility function transforms OpenAPI path syntax (using curly braces) into
+ * JavaScript template literal syntax (using ${} expressions). It's essential for
+ * generating URL builders, API client methods, and other dynamic path construction
+ * code where OpenAPI path parameters need to be interpolated at runtime.
+ *
+ * The function supports both simple parameter substitution and qualified parameter
+ * access (when parameters come from an object property).
+ *
+ * @param path - OpenAPI path string with {parameter} syntax
+ * @param queryArg - Optional object name to qualify parameter access
+ * @returns Template literal string with ${} parameter syntax
+ *
+ * @example Basic path parameter conversion
+ * ```typescript
+ * import { toPathTemplate } from '@skmtc/core';
+ *
+ * const template = toPathTemplate('/users/{id}/posts/{postId}');
+ * console.log(template); // '/users/${id}/posts/${postId}'
+ *
+ * // Usage in generated code:
+ * // const url = `/users/${id}/posts/${postId}`;
+ * ```
+ *
+ * @example With query argument qualification
+ * ```typescript
+ * const template = toPathTemplate('/users/{id}/posts/{postId}', 'params');
+ * console.log(template); // '/users/${params.id}/posts/${params.postId}'
+ *
+ * // Usage in generated code:
+ * // function buildUrl(params: {id: string, postId: string}) {
+ * //   return `/users/${params.id}/posts/${params.postId}`;
+ * // }
+ * ```
+ *
+ * @example API client method generation
+ * ```typescript
+ * class ApiClientGenerator {
+ *   generateMethod(path: string, method: string) {
+ *     const template = toPathTemplate(path, 'args');
+ *
+ *     return `
+ * async ${method}(args: PathParams) {
+ *   const url = \`${template}\`;
+ *   return this.request('${method.toUpperCase()}', url);
+ * }`;
+ *   }
+ * }
+ *
+ * const generator = new ApiClientGenerator();
+ * const method = generator.generateMethod('/users/{userId}/profile', 'getProfile');
+ *
+ * console.log(method);
+ * // async getProfile(args: PathParams) {
+ * //   const url = `/users/${args.userId}/profile`;
+ * //   return this.request('GET', url);
+ * // }
+ * ```
+ *
+ * @example URL builder generation
+ * ```typescript
+ * function generateUrlBuilder(endpoints: Array<{name: string, path: string}>) {
+ *   const builders = endpoints.map(endpoint => {
+ *     const template = toPathTemplate(endpoint.path);
+ *
+ *     return `${endpoint.name}: (${extractParams(endpoint.path)}) => \`${template}\``;
+ *   });
+ *
+ *   return `export const urls = {\n  ${builders.join(',\n  ')}\n};`;
+ * }
+ *
+ * const urlBuilder = generateUrlBuilder([
+ *   { name: 'user', path: '/users/{id}' },
+ *   { name: 'userPosts', path: '/users/{id}/posts/{postId}' }
+ * ]);
+ *
+ * // Generates:
+ * // export const urls = {
+ * //   user: (id) => `/users/${id}`,
+ * //   userPosts: (id, postId) => `/users/${id}/posts/${postId}`
+ * // };
+ * ```
+ *
+ * @example React Router integration
+ * ```typescript
+ * function generateRouteComponent(path: string, componentName: string) {
+ *   const template = toPathTemplate(path, 'params');
+ *
+ *   return `
+ * function ${componentName}() {
+ *   const params = useParams();
+ *   const apiUrl = \`/api${template}\`;
+ *
+ *   // Use apiUrl for data fetching
+ *   return <div>Content for {apiUrl}</div>;
+ * }`;
+ * }
+ * ```
+ *
+ * @example Complex nested parameters
+ * ```typescript
+ * const complexPath = '/organizations/{orgId}/projects/{projectId}/issues/{issueId}/comments/{commentId}';
+ *
+ * const simple = toPathTemplate(complexPath);
+ * console.log(simple);
+ * // '/organizations/${orgId}/projects/${projectId}/issues/${issueId}/comments/${commentId}'
+ *
+ * const qualified = toPathTemplate(complexPath, 'pathParams');
+ * console.log(qualified);
+ * // '/organizations/${pathParams.orgId}/projects/${pathParams.projectId}/issues/${pathParams.issueId}/comments/${pathParams.commentId}'
+ * ```
+ */
 export declare const toPathTemplate: (path: string, queryArg?: string) => string;
 //# sourceMappingURL=toPathTemplate.d.ts.map

package/esm/typescript/toPathTemplate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toPathTemplate.d.ts","sourceRoot":"","sources":["../../src/typescript/toPathTemplate.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,GAAI,MAAM,MAAM,EAAE,WAAW,MAAM,KAAG,MAKhE,CAAA"}
+{"version":3,"file":"toPathTemplate.d.ts","sourceRoot":"","sources":["../../src/typescript/toPathTemplate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiHG;AACH,eAAO,MAAM,cAAc,GAAI,MAAM,MAAM,EAAE,WAAW,MAAM,KAAG,MAKhE,CAAA"}

package/esm/typescript/toPathTemplate.js

@@ -1,3 +1,117 @@
+/**
+ * Converts OpenAPI path parameters into JavaScript template literal syntax.
+ *
+ * This utility function transforms OpenAPI path syntax (using curly braces) into
+ * JavaScript template literal syntax (using ${} expressions). It's essential for
+ * generating URL builders, API client methods, and other dynamic path construction
+ * code where OpenAPI path parameters need to be interpolated at runtime.
+ *
+ * The function supports both simple parameter substitution and qualified parameter
+ * access (when parameters come from an object property).
+ *
+ * @param path - OpenAPI path string with {parameter} syntax
+ * @param queryArg - Optional object name to qualify parameter access
+ * @returns Template literal string with ${} parameter syntax
+ *
+ * @example Basic path parameter conversion
+ * ```typescript
+ * import { toPathTemplate } from '@skmtc/core';
+ *
+ * const template = toPathTemplate('/users/{id}/posts/{postId}');
+ * console.log(template); // '/users/${id}/posts/${postId}'
+ *
+ * // Usage in generated code:
+ * // const url = `/users/${id}/posts/${postId}`;
+ * ```
+ *
+ * @example With query argument qualification
+ * ```typescript
+ * const template = toPathTemplate('/users/{id}/posts/{postId}', 'params');
+ * console.log(template); // '/users/${params.id}/posts/${params.postId}'
+ *
+ * // Usage in generated code:
+ * // function buildUrl(params: {id: string, postId: string}) {
+ * //   return `/users/${params.id}/posts/${params.postId}`;
+ * // }
+ * ```
+ *
+ * @example API client method generation
+ * ```typescript
+ * class ApiClientGenerator {
+ *   generateMethod(path: string, method: string) {
+ *     const template = toPathTemplate(path, 'args');
+ *
+ *     return `
+ * async ${method}(args: PathParams) {
+ *   const url = \`${template}\`;
+ *   return this.request('${method.toUpperCase()}', url);
+ * }`;
+ *   }
+ * }
+ *
+ * const generator = new ApiClientGenerator();
+ * const method = generator.generateMethod('/users/{userId}/profile', 'getProfile');
+ *
+ * console.log(method);
+ * // async getProfile(args: PathParams) {
+ * //   const url = `/users/${args.userId}/profile`;
+ * //   return this.request('GET', url);
+ * // }
+ * ```
+ *
+ * @example URL builder generation
+ * ```typescript
+ * function generateUrlBuilder(endpoints: Array<{name: string, path: string}>) {
+ *   const builders = endpoints.map(endpoint => {
+ *     const template = toPathTemplate(endpoint.path);
+ *
+ *     return `${endpoint.name}: (${extractParams(endpoint.path)}) => \`${template}\``;
+ *   });
+ *
+ *   return `export const urls = {\n  ${builders.join(',\n  ')}\n};`;
+ * }
+ *
+ * const urlBuilder = generateUrlBuilder([
+ *   { name: 'user', path: '/users/{id}' },
+ *   { name: 'userPosts', path: '/users/{id}/posts/{postId}' }
+ * ]);
+ *
+ * // Generates:
+ * // export const urls = {
+ * //   user: (id) => `/users/${id}`,
+ * //   userPosts: (id, postId) => `/users/${id}/posts/${postId}`
+ * // };
+ * ```
+ *
+ * @example React Router integration
+ * ```typescript
+ * function generateRouteComponent(path: string, componentName: string) {
+ *   const template = toPathTemplate(path, 'params');
+ *
+ *   return `
+ * function ${componentName}() {
+ *   const params = useParams();
+ *   const apiUrl = \`/api${template}\`;
+ *
+ *   // Use apiUrl for data fetching
+ *   return <div>Content for {apiUrl}</div>;
+ * }`;
+ * }
+ * ```
+ *
+ * @example Complex nested parameters
+ * ```typescript
+ * const complexPath = '/organizations/{orgId}/projects/{projectId}/issues/{issueId}/comments/{commentId}';
+ *
+ * const simple = toPathTemplate(complexPath);
+ * console.log(simple);
+ * // '/organizations/${orgId}/projects/${projectId}/issues/${issueId}/comments/${commentId}'
+ *
+ * const qualified = toPathTemplate(complexPath, 'pathParams');
+ * console.log(qualified);
+ * // '/organizations/${pathParams.orgId}/projects/${pathParams.projectId}/issues/${pathParams.issueId}/comments/${pathParams.commentId}'
+ * ```
+ */
 export const toPathTemplate = (path, queryArg) => {
     return `${path.replaceAll(/{([^}]*)}/g, queryArg ? '${' + queryArg + '.$1}' : '${$1}')}`;
 };