02-rbor 0.1.0

package/dist/templates/component/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mainComponentTemplate = void 0;
+var main_1 = require("./main");
+Object.defineProperty(exports, "mainComponentTemplate", { enumerable: true, get: function () { return main_1.mainComponentTemplate; } });
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/templates/component/index.ts"],"names":[],"mappings":";;;AAAA,+BAA+C;AAAtC,6GAAA,qBAAqB,OAAA"}

package/dist/templates/component/main.d.ts

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

package/dist/templates/component/main.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mainComponentTemplate = mainComponentTemplate;
+const naming_1 = require("../../utils/naming");
+function mainComponentTemplate(name) {
+    return `// ${name} UI component\nexport function ${(0, naming_1.toPascalCase)(name)}() {};\n`;
+}
+//# sourceMappingURL=main.js.map

package/dist/templates/component/main.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.js","sourceRoot":"","sources":["../../../src/templates/component/main.ts"],"names":[],"mappings":";;AAEA,sDAEC;AAJD,+CAAkD;AAElD,SAAgB,qBAAqB,CAAC,IAAY;IAChD,OAAO,MAAM,IAAI,kCAAkC,IAAA,qBAAY,EAAC,IAAI,CAAC,UAAU,CAAC;AAClF,CAAC"}

package/dist/templates/hooks/action.d.ts

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

package/dist/templates/hooks/action.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.actionHookTemplate = actionHookTemplate;
+const naming_1 = require("../../utils/naming");
+const naming_2 = require("../../utils/naming");
+function actionHookTemplate(name) {
+    const pascalName = (0, naming_1.toPascalCase)(name);
+    const kebabName = (0, naming_2.toKebabCase)(name);
+    const upperName = name.replace(/-/g, '_').toUpperCase();
+    return `// ${pascalName} Action Hook
+// Provides mutation actions for the ${name} domain.
+// Each action wraps a domain method with React Query's useMutation.
+
+// import { useMutation, useQueryClient } from '@tanstack/react-query';
+// import { ServiceFactory } from '../../../infrastructure/ServiceFactory';
+// import { create${pascalName}, update${pascalName}, delete${pascalName} } from '../methods/${kebabName}-logic';
+
+export const use${pascalName}Action = () => {
+  // const queryClient = useQueryClient();
+  // const service = ServiceFactory.create('${upperName}');
+
+  // const createMutation = useMutation({
+  //   mutationFn: (data: unknown) => create${pascalName}(service, data),
+  //   onSuccess: () => queryClient.invalidateQueries({ queryKey: ['${kebabName}'] }),
+  // });
+
+  // const updateMutation = useMutation({
+  //   mutationFn: ({ id, data }: { id: string; data: unknown }) =>
+  //     update${pascalName}(service, id, data),
+  //   onSuccess: () => queryClient.invalidateQueries({ queryKey: ['${kebabName}'] }),
+  // });
+
+  // const deleteMutation = useMutation({
+  //   mutationFn: (id: string) => delete${pascalName}(service, id),
+  //   onSuccess: () => queryClient.invalidateQueries({ queryKey: ['${kebabName}'] }),
+  // });
+
+  return {
+    // create: createMutation.mutateAsync,
+    // update: updateMutation.mutateAsync,
+    // remove: deleteMutation.mutateAsync,
+    // isCreating: createMutation.isPending,
+    // isUpdating: updateMutation.isPending,
+    // isDeleting: deleteMutation.isPending,
+  };
+};
+`;
+}
+//# sourceMappingURL=action.js.map

package/dist/templates/hooks/action.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"action.js","sourceRoot":"","sources":["../../../src/templates/hooks/action.ts"],"names":[],"mappings":";;AAGA,gDA2CC;AA9CD,+CAAkD;AAClD,+CAAiD;AAEjD,SAAgB,kBAAkB,CAAC,IAAY;IAC7C,MAAM,UAAU,GAAG,IAAA,qBAAY,EAAC,IAAI,CAAC,CAAC;IACtC,MAAM,SAAS,GAAG,IAAA,oBAAW,EAAC,IAAI,CAAC,CAAC;IACpC,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,WAAW,EAAE,CAAC;IAExD,OAAO,MAAM,UAAU;uCACc,IAAI;;;;;oBAKvB,UAAU,WAAW,UAAU,WAAW,UAAU,uBAAuB,SAAS;;kBAEtF,UAAU;;8CAEkB,SAAS;;;8CAGT,UAAU;sEACc,SAAS;;;;;iBAK9D,UAAU;sEAC2C,SAAS;;;;2CAIpC,UAAU;sEACiB,SAAS;;;;;;;;;;;;CAY9E,CAAC;AACF,CAAC"}

package/dist/templates/hooks/controller.d.ts

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

package/dist/templates/hooks/controller.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.controllerHookTemplate = controllerHookTemplate;
+const naming_1 = require("../../utils/naming");
+function controllerHookTemplate(name) {
+    const pascalName = (0, naming_1.toPascalCase)(name);
+    const kebabName = (0, naming_1.toKebabCase)(name);
+    const upperName = name.replace(/-/g, '_').toUpperCase();
+    return `// use${pascalName} Hook
+// This hook creates the service object and wires up all domain methods.
+// The component calls this hook to get everything it needs.
+//
+// NOTE: If you need access to the Redux store (or any other global state),
+// access it in THIS hook and pass the values down to your methods.
+// Methods should remain pure async functions — they should not import
+// from the store directly.
+
+import { ServiceFactory } from '../../../infrastructure/ServiceFactory';
+import type { ${pascalName}Service } from '../services/${kebabName}-service';
+import {
+  get${pascalName}List,
+  get${pascalName}ById,
+  create${pascalName},
+  update${pascalName},
+  delete${pascalName},
+} from '../methods/${kebabName}-logic';
+
+export const use${pascalName} = () => {
+  const service = ServiceFactory.create('${upperName}') as ${pascalName}Service;
+
+  return {
+    getList: () => get${pascalName}List(service),
+    getById: (id: string) => get${pascalName}ById(service, id),
+    create: (data: unknown) => create${pascalName}(service, data),
+    update: (id: string, data: unknown) => update${pascalName}(service, id, data),
+    remove: (id: string) => delete${pascalName}(service, id),
+  };
+};
+`;
+}
+//# sourceMappingURL=controller.js.map

package/dist/templates/hooks/controller.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"controller.js","sourceRoot":"","sources":["../../../src/templates/hooks/controller.ts"],"names":[],"mappings":";;AAEA,wDAoCC;AAtCD,+CAA+D;AAE/D,SAAgB,sBAAsB,CAAC,IAAY;IACjD,MAAM,UAAU,GAAG,IAAA,qBAAY,EAAC,IAAI,CAAC,CAAC;IACtC,MAAM,SAAS,GAAG,IAAA,oBAAW,EAAC,IAAI,CAAC,CAAC;IACpC,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,WAAW,EAAE,CAAC;IAExD,OAAO,SAAS,UAAU;;;;;;;;;;gBAUZ,UAAU,+BAA+B,SAAS;;OAE3D,UAAU;OACV,UAAU;UACP,UAAU;UACV,UAAU;UACV,UAAU;qBACC,SAAS;;kBAEZ,UAAU;2CACe,SAAS,SAAS,UAAU;;;wBAG/C,UAAU;kCACA,UAAU;uCACL,UAAU;mDACE,UAAU;oCACzB,UAAU;;;CAG7C,CAAC;AACF,CAAC"}

package/dist/templates/hooks/data.d.ts

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

package/dist/templates/hooks/data.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataHookTemplate = dataHookTemplate;
+const naming_1 = require("../../utils/naming");
+const naming_2 = require("../../utils/naming");
+function dataHookTemplate(name) {
+    const pascalName = (0, naming_1.toPascalCase)(name);
+    const kebabName = (0, naming_2.toKebabCase)(name);
+    const upperName = name.replace(/-/g, '_').toUpperCase();
+    return `// ${pascalName} Data Hook
+// Fetches server state using React Query.
+// Returns raw data — no formatting, no interpretation.
+
+// import { useQuery } from '@tanstack/react-query';
+// import { ServiceFactory } from '../../../infrastructure/ServiceFactory';
+// import { get${pascalName}List, get${pascalName}ById } from '../methods/${kebabName}-logic';
+
+/**
+ * Fetch the ${name} list
+ */
+export const use${pascalName}Data = () => {
+  // const service = ServiceFactory.create('${upperName}');
+
+  // const listQuery = useQuery({
+  //   queryKey: ['${kebabName}', 'list'],
+  //   queryFn: () => get${pascalName}List(service),
+  // });
+
+  return {
+    // items: listQuery.data ?? [],
+    // isLoading: listQuery.isLoading,
+    // error: listQuery.error,
+    // refetch: listQuery.refetch,
+  };
+};
+`;
+}
+//# sourceMappingURL=data.js.map

package/dist/templates/hooks/data.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"data.js","sourceRoot":"","sources":["../../../src/templates/hooks/data.ts"],"names":[],"mappings":";;AAGA,4CAgCC;AAnCD,+CAAkD;AAClD,+CAAiD;AAEjD,SAAgB,gBAAgB,CAAC,IAAY;IAC3C,MAAM,UAAU,GAAG,IAAA,qBAAY,EAAC,IAAI,CAAC,CAAC;IACtC,MAAM,SAAS,GAAG,IAAA,oBAAW,EAAC,IAAI,CAAC,CAAC;IACpC,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,WAAW,EAAE,CAAC;IAExD,OAAO,MAAM,UAAU;;;;;;iBAMR,UAAU,YAAY,UAAU,2BAA2B,SAAS;;;eAGtE,IAAI;;kBAED,UAAU;8CACkB,SAAS;;;qBAGlC,SAAS;2BACH,UAAU;;;;;;;;;;CAUpC,CAAC;AACF,CAAC"}

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

@@ -0,0 +1,3 @@
+export { controllerHookTemplate } from './controller';
+export { dataHookTemplate } from './data';
+export { actionHookTemplate } from './action';

package/dist/templates/hooks/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.actionHookTemplate = exports.dataHookTemplate = exports.controllerHookTemplate = void 0;
+var controller_1 = require("./controller");
+Object.defineProperty(exports, "controllerHookTemplate", { enumerable: true, get: function () { return controller_1.controllerHookTemplate; } });
+var data_1 = require("./data");
+Object.defineProperty(exports, "dataHookTemplate", { enumerable: true, get: function () { return data_1.dataHookTemplate; } });
+var action_1 = require("./action");
+Object.defineProperty(exports, "actionHookTemplate", { enumerable: true, get: function () { return action_1.actionHookTemplate; } });
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/templates/hooks/index.ts"],"names":[],"mappings":";;;AAAA,2CAAsD;AAA7C,oHAAA,sBAAsB,OAAA;AAC/B,+BAA0C;AAAjC,wGAAA,gBAAgB,OAAA;AACzB,mCAA8C;AAArC,4GAAA,kBAAkB,OAAA"}

package/dist/templates/index.d.ts

@@ -0,0 +1,10 @@
+export { barrelTemplate } from './barrel/index';
+export { controllerHookTemplate, dataHookTemplate, actionHookTemplate } from './hooks/index';
+export { mainComponentTemplate } from './component/index';
+export { servicesTemplate, baseServiceTemplate, domainServiceTemplate, axiosBaseServiceTemplate, fetchBaseServiceTemplate, kyBaseServiceTemplate, serviceFactoryTemplate, } from './services/index';
+export { methodsTemplate } from './methods/index';
+export { typesTemplate } from './types/index';
+export { utilsTemplate } from './utils/index';
+export { schemaTemplate } from './schema/index';
+export { generateUrlTemplate } from './utils/generateURL';
+export { endpointsTemplate, endpointEntryTemplate } from './utils/endpoints';

package/dist/templates/index.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.endpointEntryTemplate = exports.endpointsTemplate = exports.generateUrlTemplate = exports.schemaTemplate = exports.utilsTemplate = exports.typesTemplate = exports.methodsTemplate = exports.serviceFactoryTemplate = exports.kyBaseServiceTemplate = exports.fetchBaseServiceTemplate = exports.axiosBaseServiceTemplate = exports.domainServiceTemplate = exports.baseServiceTemplate = exports.servicesTemplate = exports.mainComponentTemplate = exports.actionHookTemplate = exports.dataHookTemplate = exports.controllerHookTemplate = exports.barrelTemplate = void 0;
+var index_1 = require("./barrel/index");
+Object.defineProperty(exports, "barrelTemplate", { enumerable: true, get: function () { return index_1.barrelTemplate; } });
+var index_2 = require("./hooks/index");
+Object.defineProperty(exports, "controllerHookTemplate", { enumerable: true, get: function () { return index_2.controllerHookTemplate; } });
+Object.defineProperty(exports, "dataHookTemplate", { enumerable: true, get: function () { return index_2.dataHookTemplate; } });
+Object.defineProperty(exports, "actionHookTemplate", { enumerable: true, get: function () { return index_2.actionHookTemplate; } });
+var index_3 = require("./component/index");
+Object.defineProperty(exports, "mainComponentTemplate", { enumerable: true, get: function () { return index_3.mainComponentTemplate; } });
+var index_4 = require("./services/index");
+Object.defineProperty(exports, "servicesTemplate", { enumerable: true, get: function () { return index_4.servicesTemplate; } });
+Object.defineProperty(exports, "baseServiceTemplate", { enumerable: true, get: function () { return index_4.baseServiceTemplate; } });
+Object.defineProperty(exports, "domainServiceTemplate", { enumerable: true, get: function () { return index_4.domainServiceTemplate; } });
+Object.defineProperty(exports, "axiosBaseServiceTemplate", { enumerable: true, get: function () { return index_4.axiosBaseServiceTemplate; } });
+Object.defineProperty(exports, "fetchBaseServiceTemplate", { enumerable: true, get: function () { return index_4.fetchBaseServiceTemplate; } });
+Object.defineProperty(exports, "kyBaseServiceTemplate", { enumerable: true, get: function () { return index_4.kyBaseServiceTemplate; } });
+Object.defineProperty(exports, "serviceFactoryTemplate", { enumerable: true, get: function () { return index_4.serviceFactoryTemplate; } });
+var index_5 = require("./methods/index");
+Object.defineProperty(exports, "methodsTemplate", { enumerable: true, get: function () { return index_5.methodsTemplate; } });
+var index_6 = require("./types/index");
+Object.defineProperty(exports, "typesTemplate", { enumerable: true, get: function () { return index_6.typesTemplate; } });
+var index_7 = require("./utils/index");
+Object.defineProperty(exports, "utilsTemplate", { enumerable: true, get: function () { return index_7.utilsTemplate; } });
+var index_8 = require("./schema/index");
+Object.defineProperty(exports, "schemaTemplate", { enumerable: true, get: function () { return index_8.schemaTemplate; } });
+var generateURL_1 = require("./utils/generateURL");
+Object.defineProperty(exports, "generateUrlTemplate", { enumerable: true, get: function () { return generateURL_1.generateUrlTemplate; } });
+var endpoints_1 = require("./utils/endpoints");
+Object.defineProperty(exports, "endpointsTemplate", { enumerable: true, get: function () { return endpoints_1.endpointsTemplate; } });
+Object.defineProperty(exports, "endpointEntryTemplate", { enumerable: true, get: function () { return endpoints_1.endpointEntryTemplate; } });
+//# sourceMappingURL=index.js.map

package/dist/templates/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/templates/index.ts"],"names":[],"mappings":";;;AAAA,wCAAgD;AAAvC,uGAAA,cAAc,OAAA;AAEvB,uCAA6F;AAApF,+GAAA,sBAAsB,OAAA;AAAE,yGAAA,gBAAgB,OAAA;AAAE,2GAAA,kBAAkB,OAAA;AAErE,2CAA0D;AAAjD,8GAAA,qBAAqB,OAAA;AAE9B,0CAQ0B;AAPxB,yGAAA,gBAAgB,OAAA;AAChB,4GAAA,mBAAmB,OAAA;AACnB,8GAAA,qBAAqB,OAAA;AACrB,iHAAA,wBAAwB,OAAA;AACxB,iHAAA,wBAAwB,OAAA;AACxB,8GAAA,qBAAqB,OAAA;AACrB,+GAAA,sBAAsB,OAAA;AAGxB,yCAAkD;AAAzC,wGAAA,eAAe,OAAA;AACxB,uCAA8C;AAArC,sGAAA,aAAa,OAAA;AACtB,uCAA8C;AAArC,sGAAA,aAAa,OAAA;AACtB,wCAAgD;AAAvC,uGAAA,cAAc,OAAA;AAEvB,mDAA0D;AAAjD,kHAAA,mBAAmB,OAAA;AAC5B,+CAA6E;AAApE,8GAAA,iBAAiB,OAAA;AAAE,kHAAA,qBAAqB,OAAA"}

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

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

package/dist/templates/methods/index.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.methodsTemplate = methodsTemplate;
+const naming_1 = require("../../utils/naming");
+function methodsTemplate(name) {
+    const pascalName = (0, naming_1.toPascalCase)(name);
+    const upperName = name.replace(/-/g, '_').toUpperCase();
+    return `// ${pascalName} Logic - Pure async functions (React-independent)
+// Each function receives the service as its first parameter for testability
+
+import type { ${pascalName}Service } from '../services/${name}-service';
+import { ${upperName}_ENDPOINTS } from '../utils/constant/${name}-endpoints';
+
+/**
+ * Fetch all ${name} items
+ */
+export const get${pascalName}List = async (
+  service: ${pascalName}Service
+): Promise<unknown[]> => {
+  const response = await service.get<unknown[]>(
+    ${upperName}_ENDPOINTS.GET_${upperName}_LIST
+  );
+  return response?.data || [];
+};
+
+/**
+ * Fetch a single ${name} by ID
+ */
+export const get${pascalName}ById = async (
+  service: ${pascalName}Service,
+  id: string
+): Promise<unknown> => {
+  const response = await service.get<unknown>(
+    ${upperName}_ENDPOINTS.GET_${upperName}_BY_ID,
+    { id }  // params - will replace :id in endpoint
+  );
+  return response?.data;
+};
+
+/**
+ * Create a new ${name}
+ */
+export const create${pascalName} = async (
+  service: ${pascalName}Service,
+  data: unknown
+): Promise<unknown> => {
+  const response = await service.post<unknown>(
+    ${upperName}_ENDPOINTS.CREATE_${upperName},
+    data
+  );
+  return response?.data;
+};
+
+/**
+ * Update an existing ${name}
+ */
+export const update${pascalName} = async (
+  service: ${pascalName}Service,
+  id: string,
+  data: unknown
+): Promise<unknown> => {
+  const response = await service.put<unknown>(
+    ${upperName}_ENDPOINTS.UPDATE_${upperName},
+    data,
+    { id }  // params - will replace :id in endpoint
+  );
+  return response?.data;
+};
+
+/**
+ * Delete a ${name}
+ */
+export const delete${pascalName} = async (
+  service: ${pascalName}Service,
+  id: string
+): Promise<unknown> => {
+  const response = await service.delete<unknown>(
+    ${upperName}_ENDPOINTS.DELETE_${upperName},
+    { id }  // params - will replace :id in endpoint
+  );
+  return response?.data;
+};
+`;
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/templates/methods/index.ts"],"names":[],"mappings":";;AAEA,0CAgFC;AAlFD,+CAAkD;AAElD,SAAgB,eAAe,CAAC,IAAY;IAC1C,MAAM,UAAU,GAAG,IAAA,qBAAY,EAAC,IAAI,CAAC,CAAC;IACtC,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,WAAW,EAAE,CAAC;IAExD,OAAO,MAAM,UAAU;;;gBAGT,UAAU,+BAA+B,IAAI;WAClD,SAAS,wCAAwC,IAAI;;;eAGjD,IAAI;;kBAED,UAAU;aACf,UAAU;;;MAGjB,SAAS,kBAAkB,SAAS;;;;;;oBAMtB,IAAI;;kBAEN,UAAU;aACf,UAAU;;;;MAIjB,SAAS,kBAAkB,SAAS;;;;;;;kBAOxB,IAAI;;qBAED,UAAU;aAClB,UAAU;;;;MAIjB,SAAS,qBAAqB,SAAS;;;;;;;wBAOrB,IAAI;;qBAEP,UAAU;aAClB,UAAU;;;;;MAKjB,SAAS,qBAAqB,SAAS;;;;;;;;cAQ/B,IAAI;;qBAEG,UAAU;aAClB,UAAU;;;;MAIjB,SAAS,qBAAqB,SAAS;;;;;CAK5C,CAAC;AACF,CAAC"}

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

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

package/dist/templates/schema/index.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schemaTemplate = schemaTemplate;
+const naming_1 = require("../../utils/naming");
+function schemaTemplate(name) {
+    const pascalName = (0, naming_1.toPascalCase)(name);
+    return `// ${pascalName} Validation Schemas
+// Define your domain entity schemas here using zod.
+// These schemas serve as the single source of truth for data shape and validation.
+
+// import { z } from 'zod';
+
+// export const ${pascalName}Schema = z.object({
+//   id: z.string(),
+//   // TODO: Add domain-specific fields
+//   createdAt: z.string().datetime(),
+//   updatedAt: z.string().datetime(),
+// });
+
+// /** Inferred TypeScript type from the schema */
+// export type ${pascalName} = z.infer<typeof ${pascalName}Schema>;
+
+// /** Schema for creating a new ${name} (omit auto-generated fields) */
+// export const Create${pascalName}Schema = ${pascalName}Schema.omit({
+//   id: true,
+//   createdAt: true,
+//   updatedAt: true,
+// });
+
+// export type Create${pascalName} = z.infer<typeof Create${pascalName}Schema>;
+
+// /** Schema for updating an existing ${name} (all fields optional) */
+// export const Update${pascalName}Schema = Create${pascalName}Schema.partial();
+
+// export type Update${pascalName} = z.infer<typeof Update${pascalName}Schema>;
+
+export {};
+`;
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/templates/schema/index.ts"],"names":[],"mappings":";;AAEA,wCAmCC;AArCD,+CAAkD;AAElD,SAAgB,cAAc,CAAC,IAAY;IACzC,MAAM,UAAU,GAAG,IAAA,qBAAY,EAAC,IAAI,CAAC,CAAC;IAEtC,OAAO,MAAM,UAAU;;;;;;kBAMP,UAAU;;;;;;;;iBAQX,UAAU,qBAAqB,UAAU;;mCAEvB,IAAI;wBACf,UAAU,YAAY,UAAU;;;;;;uBAMjC,UAAU,2BAA2B,UAAU;;yCAE7B,IAAI;wBACrB,UAAU,kBAAkB,UAAU;;uBAEvC,UAAU,2BAA2B,UAAU;;;CAGrE,CAAC;AACF,CAAC"}

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

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

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

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.axiosBaseServiceTemplate = axiosBaseServiceTemplate;
+function axiosBaseServiceTemplate() {
+    return `import axios, { type AxiosInstance, type AxiosRequestConfig } from 'axios';
+
+export interface BaseResponse<T> {
+  data: T;
+  status: number;
+  message?: string;
+}
+
+export type RequestConfig = AxiosRequestConfig;
+
+export abstract class BaseService {
+  protected readonly axios: AxiosInstance;
+
+  constructor(baseURL?: string) {
+    this.axios = axios.create({
+      baseURL: baseURL || '',
+      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 async get<T>(endpoint: string, config?: AxiosRequestConfig): Promise<BaseResponse<T>> {
+    const response = await this.axios.get<T>(endpoint, config);
+    return { data: response.data, status: response.status };
+  }
+
+  protected async post<T>(endpoint: 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 };
+  }
+
+  protected async put<T>(endpoint: 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 };
+  }
+
+  protected async patch<T>(endpoint: 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 };
+  }
+
+  protected async delete<T>(endpoint: 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-axios.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"base-service-axios.js","sourceRoot":"","sources":["../../../src/templates/services/base-service-axios.ts"],"names":[],"mappings":";;AAAA,4DAwEC;AAxED,SAAgB,wBAAwB;IACtC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsER,CAAC;AACF,CAAC"}

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

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

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

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchBaseServiceTemplate = fetchBaseServiceTemplate;
+function fetchBaseServiceTemplate() {
+    return `export interface BaseResponse<T> {
+  data: T;
+  status: number;
+  message?: string;
+}
+
+export interface RequestConfig {
+  headers?: Record<string, string>;
+  params?: Record<string, string>;
+  signal?: AbortSignal;
+}
+
+export abstract class BaseService {
+  protected readonly baseURL: string;
+  protected readonly defaultHeaders: Record<string, string>;
+
+  constructor(baseURL?: string) {
+    this.baseURL = baseURL || '';
+    this.defaultHeaders = {
+      'Content-Type': 'application/json',
+      Accept: 'application/json',
+    };
+  }
+
+  private buildURL(endpoint: string, params?: Record<string, string>): string {
+    const url = new URL(endpoint, this.baseURL || window.location.origin);
+    if (params) {
+      Object.entries(params).forEach(([key, value]) => {
+        url.searchParams.append(key, value);
+      });
+    }
+    return url.toString();
+  }
+
+  private async request<T>(
+    endpoint: string,
+    options: RequestInit & { params?: Record<string, string> } = {}
+  ): Promise<BaseResponse<T>> {
+    const { params, ...fetchOptions } = options;
+    const url = this.buildURL(endpoint, params);
+
+    const headers = {
+      ...this.defaultHeaders,
+      ...this.getAuthHeader(),
+      ...(options.headers || {}),
+    };
+
+    const response = await fetch(url, {
+      ...fetchOptions,
+      headers,
+    });
+
+    if (!response.ok) {
+      // TODO: Add error handling logic here
+      throw new Error(\`HTTP error! status: \${response.status}\`);
+    }
+
+    const data = await response.json();
+    return { data, status: response.status };
+  }
+
+  protected getAuthHeader(): Record<string, string> {
+    // TODO: Add auth token logic here
+    // const token = getToken();
+    // return token ? { Authorization: \`Bearer \${token}\` } : {};
+    return {};
+  }
+
+  protected async get<T>(endpoint: string, config?: RequestConfig): Promise<BaseResponse<T>> {
+    return this.request<T>(endpoint, {
+      method: 'GET',
+      ...config,
+    });
+  }
+
+  protected async post<T>(endpoint: string, data?: unknown, config?: RequestConfig): Promise<BaseResponse<T>> {
+    return this.request<T>(endpoint, {
+      method: 'POST',
+      body: data ? JSON.stringify(data) : undefined,
+      ...config,
+    });
+  }
+
+  protected async put<T>(endpoint: string, data?: unknown, config?: RequestConfig): Promise<BaseResponse<T>> {
+    return this.request<T>(endpoint, {
+      method: 'PUT',
+      body: data ? JSON.stringify(data) : undefined,
+      ...config,
+    });
+  }
+
+  protected async patch<T>(endpoint: string, data?: unknown, config?: RequestConfig): Promise<BaseResponse<T>> {
+    return this.request<T>(endpoint, {
+      method: 'PATCH',
+      body: data ? JSON.stringify(data) : undefined,
+      ...config,
+    });
+  }
+
+  protected async delete<T>(endpoint: string, config?: RequestConfig): Promise<BaseResponse<T>> {
+    return this.request<T>(endpoint, {
+      method: 'DELETE',
+      ...config,
+    });
+  }
+}
+`;
+}
+//# sourceMappingURL=base-service-fetch.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"base-service-fetch.js","sourceRoot":"","sources":["../../../src/templates/services/base-service-fetch.ts"],"names":[],"mappings":";;AAAA,4DA4GC;AA5GD,SAAgB,wBAAwB;IACtC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0GR,CAAC;AACF,CAAC"}

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

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