arri 0.0.5 → 0.0.7

package/dist/{codegen/index.mjs → shared/arri.0e69fc28.mjs}

@@ -1,15 +1,15 @@
-import { u as unflattenObject, p as pascalCase, i as isProcedureDefinition, a as isJsonSchemaScalarType, b as isJsonSchemaNullType, c as isJsonSchemaObject, d as isJsonSchemaEnum, e as isJsonSchemaArray, f as camelCase } from '../shared/arri.215ad025.mjs';
 import { createRequire, builtinModules } from 'module';
 import { fileURLToPath, pathToFileURL, URL } from 'url';
-import path6, { dirname } from 'path';
+import require$$0, { dirname } from 'path';
 import process4 from 'process';
-import os from 'os';
+import require$$0$1 from 'os';
 import tty from 'tty';
 import fs$1, { realpathSync, statSync, Stats, writeFileSync } from 'fs';
 import assert4 from 'assert';
 import fs from 'fs/promises';
 import v8 from 'v8';
 import { format, inspect } from 'util';
+import { g as unflattenProcedures, i as isServiceDefinition, p as pascalCase, h as camelCase, a as isProcedureDefinition, e as isJsonSchemaEnum, c as isJsonSchemaNullType, b as isJsonSchemaScalarType, d as isJsonSchemaObject, f as isJsonSchemaArray } from './arri.1f1b9dfc.mjs';
 import { execSync } from 'child_process';
 
 const require$1 = createRequire(import.meta.url);
@@ -21403,7 +21403,7 @@ function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
     return min;
   }
   if (process4.platform === "win32") {
-    const osRelease = os.release().split(".");
+    const osRelease = require$$0$1.release().split(".");
     if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
       return Number(osRelease[2]) >= 14931 ? 3 : 2;
     }
@@ -25999,10 +25999,10 @@ var partition_default = partition2;
 var import_editorconfig = __toESM(require_src(), 1);
 var import_editorconfig_to_prettier = __toESM(require_editorconfig_to_prettier(), 1);
 var MARKERS = [".git", ".hg"];
-var markerExists = (directory) => MARKERS.some((mark) => fs$1.existsSync(path6.join(directory, mark)));
+var markerExists = (directory) => MARKERS.some((mark) => fs$1.existsSync(require$$0.join(directory, mark)));
 function findProjectRoot(directory) {
   while (!markerExists(directory)) {
-    const parentDirectory = path6.resolve(directory, "..");
+    const parentDirectory = require$$0.resolve(directory, "..");
     if (parentDirectory === directory) {
       break;
     }
@@ -26015,7 +26015,7 @@ var find_project_root_default = findProjectRoot;
 // src/config/resolve-editorconfig.js
 async function loadEditorConfig(filePath) {
   const editorConfig = await import_editorconfig.default.parse(filePath, {
-    root: find_project_root_default(path6.dirname(path6.resolve(filePath)))
+    root: find_project_root_default(require$$0.dirname(require$$0.resolve(filePath)))
   });
   const config = (0, import_editorconfig_to_prettier.default)(editorConfig);
   if (config) {
@@ -26392,7 +26392,7 @@ var package_json_reader_default = reader;
 function read(jsonPath) {
   try {
     const string = fs$1.readFileSync(
-      path6.toNamespacedPath(path6.join(path6.dirname(jsonPath), "package.json")),
+      require$$0.toNamespacedPath(require$$0.join(require$$0.dirname(jsonPath), "package.json")),
       "utf8"
     );
     return { string };
@@ -26735,7 +26735,7 @@ function finalizeResolution(resolved, base, preserveSymlinks) {
   if (!preserveSymlinks) {
     const real = realpathSync(filePath);
     const { search, hash } = resolved;
-    resolved = pathToFileURL(real + (filePath.endsWith(path6.sep) ? "/" : ""));
+    resolved = pathToFileURL(real + (filePath.endsWith(require$$0.sep) ? "/" : ""));
     resolved.search = search;
     resolved.hash = hash;
   }
@@ -27534,7 +27534,7 @@ async function resolveConfig(filePath, options8) {
   };
   if (Array.isArray(merged.plugins)) {
     merged.plugins = merged.plugins.map(
-      (value) => typeof value === "string" && value.startsWith(".") ? path6.resolve(path6.dirname(result.filepath), value) : value
+      (value) => typeof value === "string" && value.startsWith(".") ? require$$0.resolve(require$$0.dirname(result.filepath), value) : value
     );
   }
   return merged;
@@ -27548,7 +27548,7 @@ function mergeOverrides(configResult, filePath) {
   const { config, filepath: configPath } = configResult || {};
   const { overrides, ...options8 } = config || {};
   if (filePath && overrides) {
-    const relativeFilePath = path6.relative(path6.dirname(configPath), filePath);
+    const relativeFilePath = require$$0.relative(require$$0.dirname(configPath), filePath);
     for (const override of overrides) {
       if (pathMatchesGlobs(
         relativeFilePath,
@@ -27594,7 +27594,7 @@ var read_file_default = readFile;
 
 // src/utils/ignore.js
 var createIgnore = import_ignore.default.default;
-var slash = path6.sep === "\\" ? (filepath) => string_replace_all_default(
+var slash = require$$0.sep === "\\" ? (filepath) => string_replace_all_default(
   /* isOptionalObject*/
   false,
   filepath,
@@ -27616,8 +27616,8 @@ async function createSingleIsIgnoredFunction(ignoreFilePath, withNodeModules) {
     allowRelativePaths: true
   }).add(content);
   return (filepath) => {
-    filepath = path6.resolve(filepath);
-    const relativePath = ignoreFilePath ? path6.relative(path6.dirname(ignoreFilePath), filepath) : path6.relative(process.cwd(), filepath);
+    filepath = require$$0.resolve(filepath);
+    const relativePath = ignoreFilePath ? require$$0.relative(require$$0.dirname(ignoreFilePath), filepath) : require$$0.relative(process.cwd(), filepath);
     return ignore.ignores(slash(relativePath));
   };
 }
@@ -27667,7 +27667,7 @@ async function getParser(filePath, options8) {
 }
 var get_file_info_default = getFileInfo;
 function importFromDirectory(specifier, directory) {
-  return import_from_file_default(specifier, path6.join(directory, "noop.js"));
+  return import_from_file_default(specifier, require$$0.join(directory, "noop.js"));
 }
 var import_from_directory_default = importFromDirectory;
 
@@ -27682,7 +27682,7 @@ var loadPluginFromDirectory = mem(
 );
 var importPlugin = mem(async (name) => {
   try {
-    return await import(pathToFileURL(path6.resolve(name)).href);
+    return await import(pathToFileURL(require$$0.resolve(name)).href);
   } catch {
     return import_from_directory_default(name, process.cwd());
   }
@@ -29033,211 +29033,6 @@ function defineClientGeneratorPlugin(plugin) {
   return plugin;
 }
 
-let createdModels = [];
-const typescriptClientGenerator = defineClientGeneratorPlugin(
-  (options) => ({
-    generator: async (def) => {
-      if (!options.name) {
-        throw new Error("Name is requires");
-      }
-      if (!options.outputFile) {
-        throw new Error("No output file specified");
-      }
-      const result = await createTypescriptClient(def, options.name);
-      writeFileSync(options.outputFile, result);
-    },
-    options
-  })
-);
-async function createTypescriptClient(def, prefix = "Client") {
-  createdModels = [];
-  const services = unflattenObject(def.procedures);
-  const serviceParts = [];
-  const modelParts = [];
-  Object.keys(services).forEach((key) => {
-    const serviceName = pascalCase(`${prefix}_${key}_service`);
-    serviceParts.push({
-      name: serviceName,
-      key,
-      content: tsServiceFromServiceDefinition(serviceName, services[key])
-    });
-  });
-  Object.keys(def.models).forEach((key) => {
-    const modelName = pascalCase(`${key}`);
-    if (!createdModels.includes(modelName)) {
-      modelParts.push(tsModelFromDefinition(modelName, def.models[key]));
-      createdModels.push(modelName);
-    }
-  });
-  return format2(
-    `/* eslint-disable */
-    import { arriRequest, ArriRequestError } from 'arri-client';
-    
-    export class ${prefix} {
-        ${serviceParts.map((service) => `${service.key}: ${service.name}`).join("\n")}
-        constructor(opts: { baseUrl?: string; headers?: Record<string, string> }) {
-            ${serviceParts.map(
-      (service) => `this.${service.key} = new ${service.name}(opts);`
-    ).join("\n")}
-        }
-    }
-
-    ${serviceParts.map((service) => service.content).join("\n")}
-    ${modelParts.join("\n")}`,
-    {
-      parser: "typescript"
-    }
-  );
-}
-function tsServiceFromServiceDefinition(name, def) {
-  const rpcParts = [];
-  const subServiceParts = [];
-  Object.keys(def).forEach((key) => {
-    const val = def[key];
-    if (isProcedureDefinition(val)) {
-      rpcParts.push(tsRpcFromProcedureDefinition(key, val));
-      return;
-    }
-    const subServiceName = pascalCase(
-      `${name.split("Service").join("")}_${key}_service`
-    );
-    subServiceParts.push({
-      name: subServiceName,
-      key,
-      content: tsServiceFromServiceDefinition(subServiceName, val)
-    });
-  });
-  return `export class ${name} {
-        baseUrl: string;
-        headers: Record<string, string>;
-        ${subServiceParts.map((service) => `${service.key}: ${service.name};`).join("\n")}
-        constructor(opts: { baseUrl?: string; headers?: Record<string, string> }) {
-            this.baseUrl = opts.baseUrl ?? "";
-            this.headers = opts.headers ?? {};
-            ${subServiceParts.map(
-    (service) => `this.${service.key} = new ${service.name}(opts);`
-  ).join("\n")}
-        }
-        ${rpcParts.join("\n")}
-    }
-    ${subServiceParts.map((service) => service.content).join("\n")}`;
-}
-function tsRpcFromProcedureDefinition(name, def) {
-  let paramStr = "";
-  let responseName = "";
-  if (def.params) {
-    paramStr = `params: ${def.params}`;
-  }
-  if (def.response) {
-    responseName = def.response;
-  }
-  return `async ${name}(${paramStr}) {
-        return arriRequest<${responseName || "undefined"}>({
-            url: \`\${this.baseUrl}${def.path}\`,
-            method: '${def.method}',
-            ${paramStr.length ? `params,` : ""}
-            headers: this.headers,
-        });
-    }`;
-}
-function tsModelFromDefinition(name, def) {
-  const fieldParts = [];
-  const subModelParts = [];
-  Object.keys(def.properties ?? {}).forEach((key) => {
-    const isOptional = !def.required?.includes(key);
-    const prop = def.properties?.[key];
-    const keyPart = isOptional ? `${key}?` : key;
-    if (isJsonSchemaScalarType(prop)) {
-      fieldParts.push(
-        tsInterfaceScalarField(key, prop, isOptional) ?? ""
-      );
-      return;
-    }
-    if (isJsonSchemaNullType(prop)) {
-      switch (prop.type) {
-        case "null":
-          fieldParts.push(`${keyPart}: null;`);
-          break;
-        case "undefined":
-          fieldParts.push(`${keyPart}: undefined`);
-          break;
-      }
-      return;
-    }
-    if (isJsonSchemaObject(prop)) {
-      const subModelName = prop.$id ?? pascalCase(`${name}_${key}`);
-      if (!createdModels.includes(subModelName)) {
-        const content = tsModelFromDefinition(
-          subModelName,
-          prop
-        );
-        subModelParts.push(content);
-      }
-      fieldParts.push(`${keyPart}: ${subModelName};`);
-      return;
-    }
-    if (isJsonSchemaEnum(prop)) {
-      const vals = prop.anyOf.map(
-        (opt) => opt.type === "string" ? `'${opt.const}'` : `${opt.const}`
-      );
-      fieldParts.push(`${keyPart}: ${vals.join(" | ")};`);
-      return;
-    }
-    if (isJsonSchemaArray(prop)) {
-      if (isJsonSchemaScalarType(prop.items)) {
-        const part = tsInterfaceScalarField(
-          key,
-          prop.items,
-          isOptional
-        ).replace(";", "[];");
-        fieldParts.push(part);
-        return;
-      }
-      if (isJsonSchemaNullType(prop.items)) {
-        if (prop.items.type === "null") {
-          fieldParts.push(`${keyPart}: null[]`);
-          return;
-        }
-        fieldParts.push(`${keyPart}: undefined[]`);
-        return;
-      }
-      if (isJsonSchemaObject(prop.items)) {
-        const subModelName = prop.items.$id ?? pascalCase(`${name}_${key}_item`);
-        if (!createdModels.includes(subModelName)) {
-          subModelParts.push(
-            tsModelFromDefinition(subModelName, prop.items)
-          );
-        }
-        fieldParts.push(`${keyPart}: ${subModelName}[];`);
-      }
-    }
-  });
-  return `export interface ${name} {
-        ${fieldParts.join("\n")}
-    }
-    ${subModelParts.join("\n")}`;
-}
-function tsInterfaceScalarField(key, prop, isOptional = false) {
-  const keyPart = isOptional ? `${key}?` : key;
-  switch (prop.type) {
-    case "string":
-      return `${keyPart}: string;`;
-    case "bigint":
-      return `${keyPart}: bigint;`;
-    case "Date":
-      return `${keyPart}: Date;`;
-    case "boolean":
-      return `${keyPart}: boolean;`;
-    case "integer":
-      return `/**
-                    * must be an integer
-                    */
-                    ${keyPart}: number;`;
-    case "number":
-      return `${keyPart}: number;`;
-  }
-}
-
 const dartClientGenerator = defineClientGeneratorPlugin(
   (options) => {
     return {
@@ -29264,20 +29059,27 @@ const generatedModels = [];
 function createDartClient(appDef, prefix = "Client") {
   const { models, procedures } = appDef;
   const serviceParts = [];
-  const services = unflattenObject(procedures);
+  const procedureParts = [];
+  const services = unflattenProcedures(procedures);
   Object.keys(services).forEach((k) => {
-    const service = services[k];
-    const serviceName = pascalCase(`$_${prefix}_${k}_service`);
-    serviceParts.push({
-      name: serviceName,
-      key: k,
-      content: dartServiceFromServiceDefinition(
-        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-        serviceName,
-        service,
-        prefix
-      )
-    });
+    const item = services[k];
+    if (isServiceDefinition(item)) {
+      const serviceName = pascalCase(`${prefix}_${k}_service`);
+      serviceParts.push({
+        name: serviceName,
+        key: k,
+        content: dartServiceFromServiceDefinition(
+          // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+          serviceName,
+          item,
+          prefix
+        )
+      });
+      return;
+    }
+    procedureParts.push(
+      dartProcedureFromServiceDefinition(prefix, k, item)
+    );
   });
   const endpoints = {};
   Object.keys(procedures).forEach((key) => {
@@ -29305,22 +29107,18 @@ import "package:http/http.dart" as http;
 import "package:arri_client/arri_client.dart";
 
 class ${prefix} {
-  final String baseUrl;
-  final Map<String, String> headers;
+  final String _baseUrl;
+  final Map<String, String> _headers;
   const ${prefix}({
-    this.baseUrl = "",
-    this.headers = const {},
-  });
-  ${prefix} withHeaders(Map<String, String> headers) {
-    return ${prefix}(
-      baseUrl: baseUrl,
-      headers: headers,
-    );
-  }
+    String baseUrl = "",
+    Map<String, String> headers = const {},
+  }): _headers = headers,
+    _baseUrl = baseUrl;
+  ${procedureParts.join("\n")}
   ${serviceParts.map(
     (service) => `${service.name} get ${service.key} {
     return ${service.name}(
-      baseUrl: baseUrl, headers: headers,
+      baseUrl: _baseUrl, headers: _headers,
     );
   }`
   ).join("\n  ")}
@@ -29332,9 +29130,9 @@ class ${prefix} {
     Encoding? encoding,
   }) async {
     return arriRequest(
-      "$baseUrl\${endpoint.path}",
+      "$_baseUrl\${endpoint.path}",
       method: endpoint.method,
-      headers: headers ?? this.headers,
+      headers: headers ?? this._headers,
       body: body,
       query: query,
       encoding: encoding,
@@ -29361,7 +29159,7 @@ enum ${prefix}Endpoints implements Comparable<${prefix}Endpoints>, ArriEndpoint
   final HttpMethod method;
 
   @override
-  compareTo(BackendEndpoints other) => name.compareTo(other.name);
+  compareTo(${prefix}Endpoints other) => name.compareTo(other.name);
 }`;
 }
 function dartServiceFromServiceDefinition(name, def, prefix = "") {
@@ -29371,62 +29169,18 @@ function dartServiceFromServiceDefinition(name, def, prefix = "") {
   Object.keys(def).forEach((key) => {
     const item = def[key];
     if (isProcedureDefinition(item)) {
-      let returnType = `Future<String>`;
-      let returnTypeName = "String";
-      if (item.response) {
-        returnType = `Future<${prefix}${item.response}>`;
-        returnTypeName = `${prefix}${item.response}`;
-      } else {
-        returnType = "Future<void>";
-      }
-      let paramsInput = "";
-      if (item.params) {
-        paramsInput = `${prefix}${item.params} params`;
-      }
-      let responseParser = "(body) => body;";
-      switch (returnType) {
-        case "Future<String>":
-          break;
-        case "Future<int>":
-          responseParser = `(body) => Int.parse(body)`;
-          break;
-        case "Future<double>":
-          responseParser = `(body) => Double.parse(body)`;
-          break;
-        case "Future<void>":
-          responseParser = `(body) {}`;
-          break;
-        case "Future<bool>":
-          responseParser = `(body) {
-                        switch(body) {
-                            case "true":
-                            case "1":
-                                return true;
-                            case "false":
-                            case "0":
-                            default:
-                                return false;
-                        }
-                    }`;
-          break;
-        default:
-          responseParser = `(body) => ${returnTypeName}.fromJson(json.decode(body))`;
-          break;
-      }
-      rpcParts.push(`${returnType} ${key}(${paramsInput}) {
-    return parsedArriRequest(
-      "$baseUrl${item.path}",
-      method: HttpMethod.${item.method},
-      headers: headers,
-      params: ${paramsInput.length ? `params.toJson()` : "null"},
-      parser: ${responseParser},
-    );
-  }`);
+      rpcParts.push(
+        dartProcedureFromServiceDefinition(prefix, key, item)
+      );
       return;
     }
-    const subServiceName = pascalCase(`${name}_${key}_Service`);
+    const nameParts = name.split("Service");
+    nameParts.pop();
+    const subServiceName = pascalCase(
+      `${nameParts.join("")}_${key}_Service`
+    );
     const subService = dartServiceFromServiceDefinition(
-      pascalCase(`${name}_${key}_Service`),
+      subServiceName,
       item,
       prefix
     );
@@ -29437,17 +29191,18 @@ function dartServiceFromServiceDefinition(name, def, prefix = "") {
     });
   });
   return `class ${serviceName} {
-  final String baseUrl;
-  final Map<String, String> headers;
+  final String _baseUrl;
+  final Map<String, String> _headers;
   const ${serviceName}({
-    this.baseUrl = "",
-    this.headers = const {},
-  });
+    String baseUrl = "",
+    Map<String, String> headers = const {},
+  }): _baseUrl = baseUrl,
+  _headers = headers;
   ${subServiceParts.map(
     (sub) => `${sub.name} get ${sub.key} {
     return ${sub.name}(
-        baseUrl: baseUrl,
-        headers: headers,
+        baseUrl: _baseUrl,
+        headers: _headers,
     );
   }`
   ).join("\n")}
@@ -29456,6 +29211,59 @@ function dartServiceFromServiceDefinition(name, def, prefix = "") {
 ${subServiceParts.map((sub) => sub.content).join("\n")}
 `;
 }
+function dartProcedureFromServiceDefinition(clientName, key, def) {
+  let returnType = `Future<String>`;
+  let returnTypeName = "String";
+  if (def.response) {
+    returnType = `Future<${clientName}${def.response}>`;
+    returnTypeName = `${clientName}${def.response}`;
+  } else {
+    returnType = "Future<void>";
+  }
+  let paramsInput = "";
+  if (def.params) {
+    paramsInput = `${clientName}${def.params} params`;
+  }
+  let responseParser = "(body) => body;";
+  switch (returnType) {
+    case "Future<String>":
+      break;
+    case "Future<int>":
+      responseParser = `(body) => Int.parse(body)`;
+      break;
+    case "Future<double>":
+      responseParser = `(body) => Double.parse(body)`;
+      break;
+    case "Future<void>":
+      responseParser = `(body) {}`;
+      break;
+    case "Future<bool>":
+      responseParser = `(body) {
+                        switch(body) {
+                            case "true":
+                            case "1":
+                                return true;
+                            case "false":
+                            case "0":
+                            default:
+                                return false;
+                        }
+                    }`;
+      break;
+    default:
+      responseParser = `(body) => ${returnTypeName}.fromJson(json.decode(body))`;
+      break;
+  }
+  return `${returnType} ${key}(${paramsInput}) {
+    return parsedArriRequest(
+      "$_baseUrl${def.path}",
+      method: HttpMethod.${def.method},
+      headers: _headers,
+      params: ${paramsInput.length ? `params.toJson()` : "null"},
+      parser: ${responseParser},
+    );
+  }`;
+}
 function dartModelFromJsonSchema(name, schema) {
   const fields = [];
   const subModelParts = [];
@@ -29537,7 +29345,7 @@ function dartPropertyTypeFromSchema(objectName, propertyName, schema) {
     for (const opt of prop.anyOf) {
       if (opt.type === "string") {
         options.push({
-          name: opt.const.toString(),
+          name: camelCase(opt.const.toString()),
           type: "String",
           value: opt.const
         });
@@ -29834,4 +29642,4 @@ function isDartTypeWithNullables(input) {
   return false;
 }
 
-export { classListTransformer, classTransformer, createDartClient, createTypescriptClient, dartClientGenerator, dartModelFromJsonSchema, dartParsedJsonField, dartPropertyTypeFromSchema, dartServiceFromServiceDefinition, defineClientGeneratorPlugin, isDartType, isDartTypeWithNullables, transformers, tsModelFromDefinition, tsRpcFromProcedureDefinition, tsServiceFromServiceDefinition, typescriptClientGenerator };
+export { dartClientGenerator as a, dartServiceFromServiceDefinition as b, createDartClient as c, defineClientGeneratorPlugin as d, dartProcedureFromServiceDefinition as e, format2 as f, dartModelFromJsonSchema as g, dartPropertyTypeFromSchema as h, dartParsedJsonField as i, classTransformer as j, classListTransformer as k, isDartType as l, isDartTypeWithNullables as m, transformers as t };