@dorval/dio 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+import { ClientGeneratorBuilder, ClientBuilder, ClientHeaderBuilder, ClientDependenciesBuilder, ClientFooterBuilder } from '@dorval/core';
+
+/**
+ * Generate Dio client builder
+ */
+declare const generateDioClient: ClientBuilder;
+/**
+ * Generate Dio header
+ */
+declare const generateDioHeader: ClientHeaderBuilder;
+/**
+ * Get Dio dependencies
+ */
+declare const getDioDependencies: ClientDependenciesBuilder;
+/**
+ * Generate Dio footer
+ */
+declare const generateDioFooter: ClientFooterBuilder;
+/**
+ * Builder factory function (following Orval pattern)
+ */
+declare const builder: () => () => ClientGeneratorBuilder;
+
+export { builder, builder as default, generateDioClient, generateDioFooter, generateDioHeader, getDioDependencies };

package/dist/index.js

@@ -0,0 +1,173 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  builder: () => builder,
+  default: () => index_default,
+  generateDioClient: () => generateDioClient,
+  generateDioFooter: () => generateDioFooter,
+  generateDioHeader: () => generateDioHeader,
+  getDioDependencies: () => getDioDependencies
+});
+module.exports = __toCommonJS(index_exports);
+var DIO_DEPENDENCIES = [
+  {
+    exports: [
+      { name: "Dio", default: false, values: false },
+      { name: "Options", default: false, values: false },
+      { name: "DioException", default: false, values: false },
+      { name: "Response", default: false, values: false }
+    ],
+    dependency: "dio"
+  }
+];
+var generateDioImplementation = ({
+  verb,
+  route,
+  operationName,
+  response,
+  body,
+  headers,
+  queryParams,
+  pathParams,
+  props,
+  override,
+  formData,
+  formUrlEncoded
+}, { output }) => {
+  const httpMethod = verb.toLowerCase();
+  const hasBody = ["post", "put", "patch"].includes(httpMethod) && body;
+  const hasQueryParams = !!queryParams;
+  const hasHeaders = !!headers;
+  const hasPathParams = pathParams && pathParams.length > 0;
+  let pathConstruction = hasPathParams ? `final path = '${route}'${pathParams.map((p) => `.replaceAll('{${p.name}}', ${p.dartName}.toString())`).join("")};` : `const path = '${route}';`;
+  let queryParamsConstruction = "";
+  if (hasQueryParams) {
+    queryParamsConstruction = `
+    final queryParameters = <String, dynamic>{
+      ${queryParams.map((q) => `if (${q.dartName} != null) '${q.name}': ${q.dartName},`).join("\n      ")}
+    };`;
+  }
+  let headersConstruction = "";
+  if (hasHeaders) {
+    headersConstruction = `
+    final requestHeaders = <String, String>{
+      ${headers.map((h) => `if (${h.dartName} != null) '${h.name}': ${h.dartName}.toString(),`).join("\n      ")}
+    };`;
+  }
+  let methodCall = `await client.${httpMethod}(
+      path,`;
+  if (hasBody) {
+    methodCall += `
+      data: ${body.dartName}${body.isModel ? ".toJson()" : ""},`;
+  }
+  if (hasQueryParams) {
+    methodCall += `
+      queryParameters: queryParameters,`;
+  }
+  if (hasHeaders) {
+    methodCall += `
+      options: Options(headers: requestHeaders),`;
+  }
+  methodCall += `
+    )`;
+  let responseHandling = "";
+  if (response.isVoid) {
+    responseHandling = "return;";
+  } else if (response.isList) {
+    responseHandling = `
+    return (response.data as List<dynamic>)
+        .map((item) => ${response.itemType}.fromJson(item as Map<String, dynamic>))
+        .toList();`;
+  } else if (response.isModel) {
+    responseHandling = `
+    return ${response.type}.fromJson(response.data as Map<String, dynamic>);`;
+  } else if (response.isPrimitive) {
+    responseHandling = `
+    return response.data as ${response.type};`;
+  } else {
+    responseHandling = `
+    return response.data;`;
+  }
+  return `
+  Future<${response.dartType}> ${operationName}(${props.map((p) => `${p.type} ${p.name}`).join(", ")}) async {
+    ${pathConstruction}
+    ${queryParamsConstruction}
+    ${headersConstruction}
+    
+    try {
+      final response = ${methodCall};
+      ${responseHandling}
+    } on DioException catch (e) {
+      throw ApiException(
+        statusCode: e.response?.statusCode,
+        message: e.message ?? 'Unknown error occurred',
+        error: e,
+      );
+    }
+  }`;
+};
+var generateDioClient = (verbOptions, options) => {
+  const implementation = generateDioImplementation(verbOptions, options);
+  const imports = [
+    "import 'package:dio/dio.dart';",
+    "import '../api_client.dart';",
+    "import '../api_exception.dart';"
+  ];
+  if (verbOptions.response?.isModel) {
+    imports.push(`import '../models/${verbOptions.response.fileName}.dart';`);
+  }
+  if (verbOptions.body?.isModel) {
+    imports.push(`import '../models/${verbOptions.body.fileName}.dart';`);
+  }
+  return { implementation, imports };
+};
+var generateDioHeader = ({ title }) => {
+  return `
+/// ${title ? `${title} - ` : ""}Generated Dio client service
+/// This service uses Dio for HTTP requests
+`;
+};
+var getDioDependencies = (hasGlobalMutator) => {
+  if (hasGlobalMutator) {
+    return [];
+  }
+  return DIO_DEPENDENCIES;
+};
+var generateDioFooter = ({ operationNames }) => {
+  return "";
+};
+var dioClientBuilder = {
+  client: generateDioClient,
+  header: generateDioHeader,
+  dependencies: getDioDependencies,
+  footer: generateDioFooter
+};
+var builder = () => () => dioClientBuilder;
+var index_default = builder;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  builder,
+  generateDioClient,
+  generateDioFooter,
+  generateDioHeader,
+  getDioDependencies
+});

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@dorval/dio",
+  "version": "0.2.0",
+  "description": "Dio client implementation for Dorval",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsup src/index.ts --dts",
+    "dev": "tsup src/index.ts --dts --watch",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@dorval/core": "*"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.3",
+    "vitest": "^0.6.3"
+  },
+  "peerDependencies": {
+    "@dorval/core": "*"
+  }
+}

package/src/index.test.ts

@@ -0,0 +1,18 @@
+import { describe, it, expect } from 'vitest';
+import { generateDioClient } from './index';
+
+describe('@dorval/dio', () => {
+  it('should export generateDioClient function', () => {
+    expect(generateDioClient).toBeDefined();
+    expect(typeof generateDioClient).toBe('function');
+  });
+
+  it('should be a client builder function', () => {
+    // generateDioClient is a ClientGeneratorBuilder function
+    // It returns a builder that will be called by the core generator
+    const builder = generateDioClient;
+    expect(builder).toBeDefined();
+    expect(typeof builder).toBe('function');
+    expect(builder.name).toBe('generateDioClient');
+  });
+});

package/src/index.ts

@@ -0,0 +1,206 @@
+import {
+  ClientBuilder,
+  ClientGeneratorBuilder,
+  ClientHeaderBuilder,
+  ClientDependenciesBuilder,
+  ClientFooterBuilder,
+  GeneratorVerbOptions,
+  GeneratorOptions,
+  GeneratorDependency,
+} from '@dorval/core';
+
+const DIO_DEPENDENCIES: GeneratorDependency[] = [
+  {
+    exports: [
+      { name: 'Dio', default: false, values: false },
+      { name: 'Options', default: false, values: false },
+      { name: 'DioException', default: false, values: false },
+      { name: 'Response', default: false, values: false },
+    ],
+    dependency: 'dio',
+  },
+];
+
+/**
+ * Generate Dio client implementation for a service method
+ */
+const generateDioImplementation = (
+  {
+    verb,
+    route,
+    operationName,
+    response,
+    body,
+    headers,
+    queryParams,
+    pathParams,
+    props,
+    override,
+    formData,
+    formUrlEncoded,
+  }: GeneratorVerbOptions,
+  { output }: GeneratorOptions,
+): string => {
+  const httpMethod = verb.toLowerCase();
+  const hasBody = ['post', 'put', 'patch'].includes(httpMethod) && body;
+  const hasQueryParams = !!queryParams;
+  const hasHeaders = !!headers;
+  const hasPathParams = pathParams && pathParams.length > 0;
+  
+  // Build path with parameters
+  let pathConstruction = hasPathParams
+    ? `final path = '${route}'${pathParams.map((p: any) => `.replaceAll('{${p.name}}', ${p.dartName}.toString())`).join('')};`
+    : `const path = '${route}';`;
+  
+  // Build query parameters
+  let queryParamsConstruction = '';
+  if (hasQueryParams) {
+    queryParamsConstruction = `
+    final queryParameters = <String, dynamic>{
+      ${queryParams.map((q: any) => `if (${q.dartName} != null) '${q.name}': ${q.dartName},`).join('\n      ')}
+    };`;
+  }
+  
+  // Build headers
+  let headersConstruction = '';
+  if (hasHeaders) {
+    headersConstruction = `
+    final requestHeaders = <String, String>{
+      ${headers.map((h: any) => `if (${h.dartName} != null) '${h.name}': ${h.dartName}.toString(),`).join('\n      ')}
+    };`;
+  }
+  
+  // Build method call
+  let methodCall = `await client.${httpMethod}(
+      path,`;
+  
+  if (hasBody) {
+    methodCall += `
+      data: ${body.dartName}${body.isModel ? '.toJson()' : ''},`;
+  }
+  
+  if (hasQueryParams) {
+    methodCall += `
+      queryParameters: queryParameters,`;
+  }
+  
+  if (hasHeaders) {
+    methodCall += `
+      options: Options(headers: requestHeaders),`;
+  }
+  
+  methodCall += `
+    )`;
+  
+  // Build response handling
+  let responseHandling = '';
+  if (response.isVoid) {
+    responseHandling = 'return;';
+  } else if (response.isList) {
+    responseHandling = `
+    return (response.data as List<dynamic>)
+        .map((item) => ${response.itemType}.fromJson(item as Map<String, dynamic>))
+        .toList();`;
+  } else if (response.isModel) {
+    responseHandling = `
+    return ${response.type}.fromJson(response.data as Map<String, dynamic>);`;
+  } else if (response.isPrimitive) {
+    responseHandling = `
+    return response.data as ${response.type};`;
+  } else {
+    responseHandling = `
+    return response.data;`;
+  }
+  
+  // Build complete implementation
+  return `
+  Future<${response.dartType}> ${operationName}(${props.map((p: any) => `${p.type} ${p.name}`).join(', ')}) async {
+    ${pathConstruction}
+    ${queryParamsConstruction}
+    ${headersConstruction}
+    
+    try {
+      final response = ${methodCall};
+      ${responseHandling}
+    } on DioException catch (e) {
+      throw ApiException(
+        statusCode: e.response?.statusCode,
+        message: e.message ?? 'Unknown error occurred',
+        error: e,
+      );
+    }
+  }`;
+};
+
+/**
+ * Generate Dio client builder
+ */
+export const generateDioClient: ClientBuilder = (
+  verbOptions: GeneratorVerbOptions,
+  options: GeneratorOptions,
+) => {
+  const implementation = generateDioImplementation(verbOptions, options);
+  
+  const imports = [
+    "import 'package:dio/dio.dart';",
+    "import '../api_client.dart';",
+    "import '../api_exception.dart';",
+  ];
+  
+  // Add model imports if needed
+  if (verbOptions.response?.isModel) {
+    imports.push(`import '../models/${verbOptions.response.fileName}.dart';`);
+  }
+  
+  if (verbOptions.body?.isModel) {
+    imports.push(`import '../models/${verbOptions.body.fileName}.dart';`);
+  }
+  
+  return { implementation, imports };
+};
+
+/**
+ * Generate Dio header
+ */
+export const generateDioHeader: ClientHeaderBuilder = ({ title }) => {
+  return `
+/// ${title ? `${title} - ` : ''}Generated Dio client service
+/// This service uses Dio for HTTP requests
+`;
+};
+
+/**
+ * Get Dio dependencies
+ */
+export const getDioDependencies: ClientDependenciesBuilder = (
+  hasGlobalMutator: boolean,
+) => {
+  if (hasGlobalMutator) {
+    return []; // Don't include Dio dependencies if using custom mutator
+  }
+  return DIO_DEPENDENCIES;
+};
+
+/**
+ * Generate Dio footer
+ */
+export const generateDioFooter: ClientFooterBuilder = ({ operationNames }) => {
+  return ''; // No special footer needed for Dio
+};
+
+/**
+ * Dio client builder configuration
+ */
+const dioClientBuilder: ClientGeneratorBuilder = {
+  client: generateDioClient,
+  header: generateDioHeader,
+  dependencies: getDioDependencies,
+  footer: generateDioFooter,
+};
+
+/**
+ * Builder factory function (following Orval pattern)
+ */
+export const builder = () => () => dioClientBuilder;
+
+export default builder;

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "composite": false,
+    "declaration": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"],
+  "references": []
+}