02-rbor 0.1.0

package/dist/templates/services/base-service-ky.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kyBaseServiceTemplate = kyBaseServiceTemplate;
+function kyBaseServiceTemplate() {
+    return `import ky, { type KyInstance, type Options } from 'ky';
+
+export interface BaseResponse<T> {
+  data: T;
+  status: number;
+  message?: string;
+}
+
+export type RequestConfig = Options;
+
+export abstract class BaseService {
+  protected readonly client: KyInstance;
+
+  constructor(baseURL?: string) {
+    this.client = ky.create({
+      prefixUrl: baseURL || '',
+      timeout: 30000,
+      headers: {
+        'Content-Type': 'application/json',
+        Accept: 'application/json',
+      },
+      hooks: {
+        beforeRequest: [
+          (request) => {
+            // TODO: Add auth token logic here
+            // const token = getToken();
+            // if (token) request.headers.set('Authorization', \`Bearer \${token}\`);
+          },
+        ],
+        afterResponse: [
+          async (request, options, response) => {
+            // TODO: Add response handling logic here
+            return response;
+          },
+        ],
+      },
+    });
+  }
+
+  protected async get<T>(endpoint: string, options?: Options): Promise<BaseResponse<T>> {
+    const response = await this.client.get(endpoint, options);
+    const data = await response.json<T>();
+    return { data, status: response.status };
+  }
+
+  protected async post<T>(endpoint: string, data?: unknown, options?: Options): Promise<BaseResponse<T>> {
+    const response = await this.client.post(endpoint, {
+      json: data,
+      ...options,
+    });
+    const responseData = await response.json<T>();
+    return { data: responseData, status: response.status };
+  }
+
+  protected async put<T>(endpoint: string, data?: unknown, options?: Options): Promise<BaseResponse<T>> {
+    const response = await this.client.put(endpoint, {
+      json: data,
+      ...options,
+    });
+    const responseData = await response.json<T>();
+    return { data: responseData, status: response.status };
+  }
+
+  protected async patch<T>(endpoint: string, data?: unknown, options?: Options): Promise<BaseResponse<T>> {
+    const response = await this.client.patch(endpoint, {
+      json: data,
+      ...options,
+    });
+    const responseData = await response.json<T>();
+    return { data: responseData, status: response.status };
+  }
+
+  protected async delete<T>(endpoint: string, options?: Options): Promise<BaseResponse<T>> {
+    const response = await this.client.delete(endpoint, options);
+    const data = await response.json<T>();
+    return { data, status: response.status };
+  }
+}
+`;
+}
+//# sourceMappingURL=base-service-ky.js.map

package/dist/templates/services/base-service-ky.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-service-ky.js","sourceRoot":"","sources":["../../../src/templates/services/base-service-ky.ts"],"names":[],"mappings":";;AAAA,sDAgFC;AAhFD,SAAgB,qBAAqB;IACnC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8ER,CAAC;AACF,CAAC"}

package/dist/templates/services/base-service.d.ts

@@ -0,0 +1 @@
+export declare function baseServiceTemplate(): string;

package/dist/templates/services/base-service.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.baseServiceTemplate = baseServiceTemplate;
+function baseServiceTemplate() {
+    return `import axios, { type AxiosInstance, type AxiosRequestConfig } from 'axios';
+
+export interface BaseResponse<T> {
+  data: T;
+  status: number;
+  message?: string;
+}
+
+export interface ErrorContext {
+  functionName: string;
+  method: string;
+  filePath: string;
+}
+
+// Configure your base URL here
+const BASE_URL = process.env.API_BASE_URL || 'http://localhost:3000';
+
+export abstract class BaseService {
+  protected readonly axios: AxiosInstance;
+
+  constructor() {
+    this.axios = axios.create({
+      baseURL: BASE_URL,
+      timeout: 30000,
+      headers: {
+        'Content-Type': 'application/json',
+        Accept: 'application/json',
+      },
+    });
+    this.setupInterceptors();
+  }
+
+  private setupInterceptors(): void {
+    this.axios.interceptors.request.use(
+      (config) => {
+        // TODO: Add auth token logic here
+        // const token = getToken();
+        // if (token) config.headers.Authorization = \`Bearer \${token}\`;
+        return config;
+      },
+      (error) => Promise.reject(error)
+    );
+
+    this.axios.interceptors.response.use(
+      (response) => response,
+      (error) => {
+        // TODO: Add error handling logic here
+        return Promise.reject(error);
+      }
+    );
+  }
+
+  protected getErrorContext(functionName: string, method: string): ErrorContext {
+    return {
+      functionName,
+      method,
+      filePath: this.constructor.name,
+    };
+  }
+
+  async get<T>(endpoint: string, functionName: string, config?: AxiosRequestConfig): Promise<BaseResponse<T>> {
+    const response = await this.axios.get<T>(endpoint, config);
+    return { data: response.data, status: response.status };
+  }
+
+  async post<T>(endpoint: string, functionName: string, data?: unknown, config?: AxiosRequestConfig): Promise<BaseResponse<T>> {
+    const response = await this.axios.post<T>(endpoint, data, config);
+    return { data: response.data, status: response.status };
+  }
+
+  async put<T>(endpoint: string, functionName: string, data?: unknown, config?: AxiosRequestConfig): Promise<BaseResponse<T>> {
+    const response = await this.axios.put<T>(endpoint, data, config);
+    return { data: response.data, status: response.status };
+  }
+
+  async patch<T>(endpoint: string, functionName: string, data?: unknown, config?: AxiosRequestConfig): Promise<BaseResponse<T>> {
+    const response = await this.axios.patch<T>(endpoint, data, config);
+    return { data: response.data, status: response.status };
+  }
+
+  async delete<T>(endpoint: string, functionName: string, config?: AxiosRequestConfig): Promise<BaseResponse<T>> {
+    const response = await this.axios.delete<T>(endpoint, config);
+    return { data: response.data, status: response.status };
+  }
+}
+`;
+}
+//# sourceMappingURL=base-service.js.map

package/dist/templates/services/base-service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-service.js","sourceRoot":"","sources":["../../../src/templates/services/base-service.ts"],"names":[],"mappings":";;AAAA,kDAuFC;AAvFD,SAAgB,mBAAmB;IACjC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqFR,CAAC;AACF,CAAC"}

package/dist/templates/services/domain-service.d.ts

@@ -0,0 +1,2 @@
+import type { HttpClient } from '../../cli';
+export declare function domainServiceTemplate(name: string, httpClient?: HttpClient): string;

package/dist/templates/services/domain-service.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.domainServiceTemplate = domainServiceTemplate;
+const naming_1 = require("../../utils/naming");
+function getConfigImport(httpClient) {
+    switch (httpClient) {
+        case 'axios':
+            return `import type { AxiosRequestConfig } from 'axios';`;
+        case 'ky':
+            return `import type { Options as KyOptions } from 'ky';`;
+        case 'fetch':
+            return ``;
+    }
+}
+function getConfigTypeName(httpClient) {
+    switch (httpClient) {
+        case 'axios':
+            return 'AxiosRequestConfig';
+        case 'ky':
+            return 'KyOptions';
+        case 'fetch':
+            return 'RequestConfig';
+    }
+}
+function domainServiceTemplate(name, httpClient = 'axios') {
+    const pascalName = (0, naming_1.toPascalCase)(name);
+    const configImport = getConfigImport(httpClient);
+    const configType = getConfigTypeName(httpClient);
+    const baseServiceImport = httpClient === 'fetch'
+        ? `import { BaseService, type BaseResponse, type RequestConfig } from '../../../infrastructure/BaseService';`
+        : `import { BaseService, type BaseResponse } from '../../../infrastructure/BaseService';`;
+    return `// ${pascalName} Service
+
+${configImport}
+${baseServiceImport}
+import { generateUrl, type UrlParams, type QueryParams } from '../../../infrastructure/generateURL';
+
+export class ${pascalName}Service extends BaseService {
+  /**
+   * GET request with URL parameter substitution
+   */
+  async get<T>(
+    endpoint: string,
+    params?: UrlParams,
+    query?: QueryParams,
+    config?: ${configType}
+  ): Promise<BaseResponse<T>> {
+    const url = generateUrl(endpoint, params, query);
+    return super.get<T>(url, config);
+  }
+
+  /**
+   * POST request with URL parameter substitution
+   */
+  async post<T>(
+    endpoint: string,
+    data?: unknown,
+    params?: UrlParams,
+    query?: QueryParams,
+    config?: ${configType}
+  ): Promise<BaseResponse<T>> {
+    const url = generateUrl(endpoint, params, query);
+    return super.post<T>(url, data, config);
+  }
+
+  /**
+   * PUT request with URL parameter substitution
+   */
+  async put<T>(
+    endpoint: string,
+    data?: unknown,
+    params?: UrlParams,
+    query?: QueryParams,
+    config?: ${configType}
+  ): Promise<BaseResponse<T>> {
+    const url = generateUrl(endpoint, params, query);
+    return super.put<T>(url, data, config);
+  }
+
+  /**
+   * DELETE request with URL parameter substitution
+   */
+  async delete<T>(
+    endpoint: string,
+    params?: UrlParams,
+    query?: QueryParams,
+    config?: ${configType}
+  ): Promise<BaseResponse<T>> {
+    const url = generateUrl(endpoint, params, query);
+    return super.delete<T>(url, config);
+  }
+}
+`;
+}
+//# sourceMappingURL=domain-service.js.map

package/dist/templates/services/domain-service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain-service.js","sourceRoot":"","sources":["../../../src/templates/services/domain-service.ts"],"names":[],"mappings":";;AAyBA,sDAwEC;AAjGD,+CAAkD;AAGlD,SAAS,eAAe,CAAC,UAAsB;IAC7C,QAAQ,UAAU,EAAE,CAAC;QACnB,KAAK,OAAO;YACV,OAAO,kDAAkD,CAAC;QAC5D,KAAK,IAAI;YACP,OAAO,iDAAiD,CAAC;QAC3D,KAAK,OAAO;YACV,OAAO,EAAE,CAAC;IACd,CAAC;AACH,CAAC;AAED,SAAS,iBAAiB,CAAC,UAAsB;IAC/C,QAAQ,UAAU,EAAE,CAAC;QACnB,KAAK,OAAO;YACV,OAAO,oBAAoB,CAAC;QAC9B,KAAK,IAAI;YACP,OAAO,WAAW,CAAC;QACrB,KAAK,OAAO;YACV,OAAO,eAAe,CAAC;IAC3B,CAAC;AACH,CAAC;AAED,SAAgB,qBAAqB,CAAC,IAAY,EAAE,aAAyB,OAAO;IAClF,MAAM,UAAU,GAAG,IAAA,qBAAY,EAAC,IAAI,CAAC,CAAC;IACtC,MAAM,YAAY,GAAG,eAAe,CAAC,UAAU,CAAC,CAAC;IACjD,MAAM,UAAU,GAAG,iBAAiB,CAAC,UAAU,CAAC,CAAC;IAEjD,MAAM,iBAAiB,GACrB,UAAU,KAAK,OAAO;QACpB,CAAC,CAAC,2GAA2G;QAC7G,CAAC,CAAC,uFAAuF,CAAC;IAE9F,OAAO,MAAM,UAAU;;EAEvB,YAAY;EACZ,iBAAiB;;;eAGJ,UAAU;;;;;;;;eAQV,UAAU;;;;;;;;;;;;;;eAcV,UAAU;;;;;;;;;;;;;;eAcV,UAAU;;;;;;;;;;;;;eAaV,UAAU;;;;;;CAMxB,CAAC;AACF,CAAC"}

package/dist/templates/services/index.d.ts

@@ -0,0 +1,7 @@
+export { axiosBaseServiceTemplate } from './base-service-axios';
+export { fetchBaseServiceTemplate } from './base-service-fetch';
+export { kyBaseServiceTemplate } from './base-service-ky';
+export { domainServiceTemplate } from './domain-service';
+export { serviceFactoryTemplate, getServiceImport, getServiceOverload, getServiceCase, } from './service-factory';
+export { baseServiceTemplate } from './base-service';
+export declare function servicesTemplate(name: string): string;

package/dist/templates/services/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.baseServiceTemplate = exports.getServiceCase = exports.getServiceOverload = exports.getServiceImport = exports.serviceFactoryTemplate = exports.domainServiceTemplate = exports.kyBaseServiceTemplate = exports.fetchBaseServiceTemplate = exports.axiosBaseServiceTemplate = void 0;
+exports.servicesTemplate = servicesTemplate;
+var base_service_axios_1 = require("./base-service-axios");
+Object.defineProperty(exports, "axiosBaseServiceTemplate", { enumerable: true, get: function () { return base_service_axios_1.axiosBaseServiceTemplate; } });
+var base_service_fetch_1 = require("./base-service-fetch");
+Object.defineProperty(exports, "fetchBaseServiceTemplate", { enumerable: true, get: function () { return base_service_fetch_1.fetchBaseServiceTemplate; } });
+var base_service_ky_1 = require("./base-service-ky");
+Object.defineProperty(exports, "kyBaseServiceTemplate", { enumerable: true, get: function () { return base_service_ky_1.kyBaseServiceTemplate; } });
+var domain_service_1 = require("./domain-service");
+Object.defineProperty(exports, "domainServiceTemplate", { enumerable: true, get: function () { return domain_service_1.domainServiceTemplate; } });
+var service_factory_1 = require("./service-factory");
+Object.defineProperty(exports, "serviceFactoryTemplate", { enumerable: true, get: function () { return service_factory_1.serviceFactoryTemplate; } });
+Object.defineProperty(exports, "getServiceImport", { enumerable: true, get: function () { return service_factory_1.getServiceImport; } });
+Object.defineProperty(exports, "getServiceOverload", { enumerable: true, get: function () { return service_factory_1.getServiceOverload; } });
+Object.defineProperty(exports, "getServiceCase", { enumerable: true, get: function () { return service_factory_1.getServiceCase; } });
+var base_service_1 = require("./base-service");
+Object.defineProperty(exports, "baseServiceTemplate", { enumerable: true, get: function () { return base_service_1.baseServiceTemplate; } });
+function servicesTemplate(name) {
+    return `// ${name} API and external services\nexport {};\n`;
+}
+//# sourceMappingURL=index.js.map

package/dist/templates/services/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/templates/services/index.ts"],"names":[],"mappings":";;;AAeA,4CAEC;AAjBD,2DAAgE;AAAvD,8HAAA,wBAAwB,OAAA;AACjC,2DAAgE;AAAvD,8HAAA,wBAAwB,OAAA;AACjC,qDAA0D;AAAjD,wHAAA,qBAAqB,OAAA;AAE9B,mDAAyD;AAAhD,uHAAA,qBAAqB,OAAA;AAE9B,qDAK2B;AAJzB,yHAAA,sBAAsB,OAAA;AACtB,mHAAA,gBAAgB,OAAA;AAChB,qHAAA,kBAAkB,OAAA;AAClB,iHAAA,cAAc,OAAA;AAGhB,+CAAqD;AAA5C,mHAAA,mBAAmB,OAAA;AAE5B,SAAgB,gBAAgB,CAAC,IAAY;IAC3C,OAAO,MAAM,IAAI,0CAA0C,CAAC;AAC9D,CAAC"}

package/dist/templates/services/service-factory.d.ts

@@ -0,0 +1,4 @@
+export declare function serviceFactoryTemplate(domainName: string, servicePath: string): string;
+export declare function getServiceImport(domainName: string, servicePath: string): string;
+export declare function getServiceOverload(domainName: string): string;
+export declare function getServiceCase(domainName: string): string;

package/dist/templates/services/service-factory.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serviceFactoryTemplate = serviceFactoryTemplate;
+exports.getServiceImport = getServiceImport;
+exports.getServiceOverload = getServiceOverload;
+exports.getServiceCase = getServiceCase;
+const naming_1 = require("../../utils/naming");
+function serviceFactoryTemplate(domainName, servicePath) {
+    const pascalName = (0, naming_1.toPascalCase)(domainName);
+    const upperName = domainName.replace(/-/g, '').toUpperCase();
+    return `// Domain Service Imports
+import { ${pascalName}Service } from '${servicePath}';
+
+// Type Imports
+import type { BaseService } from './BaseService';
+
+/**
+ * Supported service types - auto-updated when new domains are created
+ */
+type ServiceType = "${upperName}";
+
+/**
+ * ServiceFactory - Creates service instances per domain
+ */
+export class ServiceFactory {
+  /**
+   * ${pascalName} Service
+   */
+  static create(type: "${upperName}"): ${pascalName}Service;
+
+  /**
+   * Implementation
+   */
+  static create(type: ServiceType): BaseService {
+    return this.createService(type);
+  }
+
+  private static createService(type: ServiceType): BaseService {
+    switch (type) {
+      case "${upperName}":
+        return new ${pascalName}Service();
+
+      default:
+        throw new Error(\`Unknown service type: \${type}\`);
+    }
+  }
+}
+`;
+}
+function getServiceImport(domainName, servicePath) {
+    const pascalName = (0, naming_1.toPascalCase)(domainName);
+    return `import { ${pascalName}Service } from '${servicePath}';`;
+}
+function getServiceOverload(domainName) {
+    const pascalName = (0, naming_1.toPascalCase)(domainName);
+    const upperName = domainName.replace(/-/g, '').toUpperCase();
+    return `  /**
+   * ${pascalName} Service
+   */
+  static create(type: "${upperName}"): ${pascalName}Service;`;
+}
+function getServiceCase(domainName) {
+    const pascalName = (0, naming_1.toPascalCase)(domainName);
+    const upperName = domainName.replace(/-/g, '').toUpperCase();
+    return `      case "${upperName}":
+        return new ${pascalName}Service();`;
+}
+//# sourceMappingURL=service-factory.js.map

package/dist/templates/services/service-factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-factory.js","sourceRoot":"","sources":["../../../src/templates/services/service-factory.ts"],"names":[],"mappings":";;AAEA,wDA0CC;AAED,4CAGC;AAED,gDAOC;AAED,wCAKC;AAjED,+CAAkD;AAElD,SAAgB,sBAAsB,CAAC,UAAkB,EAAE,WAAmB;IAC5E,MAAM,UAAU,GAAG,IAAA,qBAAY,EAAC,UAAU,CAAC,CAAC;IAC5C,MAAM,SAAS,GAAG,UAAU,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC;IAE7D,OAAO;WACE,UAAU,mBAAmB,WAAW;;;;;;;;sBAQ7B,SAAS;;;;;;;OAOxB,UAAU;;yBAEQ,SAAS,OAAO,UAAU;;;;;;;;;;;cAWrC,SAAS;qBACF,UAAU;;;;;;;CAO9B,CAAC;AACF,CAAC;AAED,SAAgB,gBAAgB,CAAC,UAAkB,EAAE,WAAmB;IACtE,MAAM,UAAU,GAAG,IAAA,qBAAY,EAAC,UAAU,CAAC,CAAC;IAC5C,OAAO,YAAY,UAAU,mBAAmB,WAAW,IAAI,CAAC;AAClE,CAAC;AAED,SAAgB,kBAAkB,CAAC,UAAkB;IACnD,MAAM,UAAU,GAAG,IAAA,qBAAY,EAAC,UAAU,CAAC,CAAC;IAC5C,MAAM,SAAS,GAAG,UAAU,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC;IAC7D,OAAO;OACF,UAAU;;yBAEQ,SAAS,OAAO,UAAU,UAAU,CAAC;AAC9D,CAAC;AAED,SAAgB,cAAc,CAAC,UAAkB;IAC/C,MAAM,UAAU,GAAG,IAAA,qBAAY,EAAC,UAAU,CAAC,CAAC;IAC5C,MAAM,SAAS,GAAG,UAAU,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC;IAC7D,OAAO,eAAe,SAAS;qBACZ,UAAU,YAAY,CAAC;AAC5C,CAAC"}

package/dist/templates/types/index.d.ts

@@ -0,0 +1 @@
+export declare function typesTemplate(name: string): string;

package/dist/templates/types/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typesTemplate = typesTemplate;
+function typesTemplate(name) {
+    return `// ${name} types\n\nexport {}\n`;
+}
+//# sourceMappingURL=index.js.map

package/dist/templates/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/templates/types/index.ts"],"names":[],"mappings":";;AAAA,sCAEC;AAFD,SAAgB,aAAa,CAAC,IAAY;IACxC,OAAO,MAAM,IAAI,uBAAuB,CAAC;AAC3C,CAAC"}

package/dist/templates/utils/build-url.d.ts

@@ -0,0 +1 @@
+export declare function buildUrlTemplate(): string;

package/dist/templates/utils/build-url.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildUrlTemplate = buildUrlTemplate;
+function buildUrlTemplate() {
+    return `/**
+ * URL Builder Utility
+ * Constructs URLs with route parameters and query strings
+ */
+
+export interface UrlParams {
+  [key: string]: string | number;
+}
+
+export interface QueryParams {
+  [key: string]: string | number | boolean | undefined | null;
+}
+
+/**
+ * Builds a complete URL from a route template, path parameters, and query parameters
+ * 
+ * @param route - The route template (e.g., '/users/:id/posts')
+ * @param params - Path parameters to substitute (e.g., { id: '123' })
+ * @param query - Query parameters to append (e.g., { page: 1, limit: 10 })
+ * @returns The constructed URL string
+ * 
+ * @example
+ * buildUrl('/users/:id', { id: '123' })
+ * // => '/users/123'
+ * 
+ * @example
+ * buildUrl('/users/:id/posts', { id: '123' }, { page: 1, limit: 10 })
+ * // => '/users/123/posts?page=1&limit=10'
+ * 
+ * @example
+ * buildUrl('/search', undefined, { q: 'hello', filter: 'active' })
+ * // => '/search?q=hello&filter=active'
+ */
+export function buildUrl(
+  route: string,
+  params?: UrlParams,
+  query?: QueryParams
+): string {
+  let url = route;
+
+  // Substitute path parameters
+  if (params) {
+    Object.entries(params).forEach(([key, value]) => {
+      url = url.replace(\`:$\{key}\`, String(value));
+    });
+  }
+
+  // Append query parameters
+  if (query) {
+    const searchParams = new URLSearchParams();
+    
+    Object.entries(query).forEach(([key, value]) => {
+      if (value !== undefined && value !== null) {
+        searchParams.append(key, String(value));
+      }
+    });
+
+    const queryString = searchParams.toString();
+    if (queryString) {
+      url += \`?$\{queryString}\`;
+    }
+  }
+
+  return url;
+}
+`;
+}
+//# sourceMappingURL=build-url.js.map

package/dist/templates/utils/build-url.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-url.js","sourceRoot":"","sources":["../../../src/templates/utils/build-url.ts"],"names":[],"mappings":";;AAAA,4CAmEC;AAnED,SAAgB,gBAAgB;IAC9B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiER,CAAC;AACF,CAAC"}

package/dist/templates/utils/endpoints.d.ts

@@ -0,0 +1,2 @@
+export declare function endpointsTemplate(name: string): string;
+export declare function endpointEntryTemplate(key: string, path: string): string;

package/dist/templates/utils/endpoints.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.endpointsTemplate = endpointsTemplate;
+exports.endpointEntryTemplate = endpointEntryTemplate;
+const naming_1 = require("../../utils/naming");
+function endpointsTemplate(name) {
+    const upperName = name.replace(/-/g, '_').toUpperCase();
+    const pascalName = (0, naming_1.toPascalCase)(name);
+    return `// ${pascalName} Endpoints
+
+export const ${upperName}_ENDPOINTS = {
+  GET_${upperName}_LIST: '/${name}',
+  GET_${upperName}_BY_ID: '/${name}/:id',
+  CREATE_${upperName}: '/${name}',
+  UPDATE_${upperName}: '/${name}/:id',
+  DELETE_${upperName}: '/${name}/:id',
+} as const;
+`;
+}
+function endpointEntryTemplate(key, path) {
+    return `  ${key}: '${path}',`;
+}
+//# sourceMappingURL=endpoints.js.map

package/dist/templates/utils/endpoints.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"endpoints.js","sourceRoot":"","sources":["../../../src/templates/utils/endpoints.ts"],"names":[],"mappings":";;AAEA,8CAcC;AAED,sDAEC;AApBD,+CAAkD;AAElD,SAAgB,iBAAiB,CAAC,IAAY;IAC5C,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,WAAW,EAAE,CAAC;IACxD,MAAM,UAAU,GAAG,IAAA,qBAAY,EAAC,IAAI,CAAC,CAAC;IAEtC,OAAO,MAAM,UAAU;;eAEV,SAAS;QAChB,SAAS,YAAY,IAAI;QACzB,SAAS,aAAa,IAAI;WACvB,SAAS,OAAO,IAAI;WACpB,SAAS,OAAO,IAAI;WACpB,SAAS,OAAO,IAAI;;CAE9B,CAAC;AACF,CAAC;AAED,SAAgB,qBAAqB,CAAC,GAAW,EAAE,IAAY;IAC7D,OAAO,KAAK,GAAG,MAAM,IAAI,IAAI,CAAC;AAChC,CAAC"}

package/dist/templates/utils/generateURL.d.ts

@@ -0,0 +1 @@
+export declare function generateUrlTemplate(): string;

package/dist/templates/utils/generateURL.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateUrlTemplate = generateUrlTemplate;
+function generateUrlTemplate() {
+    return `// URL Generator Utility
+
+export type UrlParams = Record<string, string | number>;
+export type QueryParams = Record<string, string | number | boolean | undefined | null>;
+
+export function generateUrl(
+  route: string,
+  params?: UrlParams,
+  query?: QueryParams
+): string {
+  let url = route;
+
+  if (params) {
+    Object.entries(params).forEach(([key, value]) => {
+      url = url.replace(\`:$\{key}\`, encodeURIComponent(String(value)));
+    });
+  }
+
+  if (query) {
+    const searchParams = new URLSearchParams();
+    Object.entries(query).forEach(([key, value]) => {
+      if (value !== undefined && value !== null) {
+        searchParams.append(key, String(value));
+      }
+    });
+    const queryString = searchParams.toString();
+    if (queryString) {
+      url += \`?$\{queryString}\`;
+    }
+  }
+
+  return url;
+}
+`;
+}
+//# sourceMappingURL=generateURL.js.map

package/dist/templates/utils/generateURL.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateURL.js","sourceRoot":"","sources":["../../../src/templates/utils/generateURL.ts"],"names":[],"mappings":";;AAAA,kDAmCC;AAnCD,SAAgB,mBAAmB;IACjC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCR,CAAC;AACF,CAAC"}

package/dist/templates/utils/index.d.ts

@@ -0,0 +1 @@
+export declare function utilsTemplate(name: string): string;

package/dist/templates/utils/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.utilsTemplate = utilsTemplate;
+function utilsTemplate(name) {
+    return `// ${name} utility functions\nexport {};\n`;
+}
+//# sourceMappingURL=index.js.map

package/dist/templates/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/templates/utils/index.ts"],"names":[],"mappings":";;AAAA,sCAEC;AAFD,SAAgB,aAAa,CAAC,IAAY;IACxC,OAAO,MAAM,IAAI,kCAAkC,CAAC;AACtD,CAAC"}