arri 0.0.6 → 0.0.7

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { d as ArriProcedure, c as ArriProcedureBase, g as ArriProcedureHandler, h as ArriProcedurePostHandler, q as ArriRoute, v as ArriRouteHandler, y as ArriRoutePostHandler, A as ArriServer, a as ArriService, E as ExtractParam, u as ExtractParams, e as HandlerContext, b as HttpMethod, H as HttpMethodValues, M as Middleware, w as RouteHandlerContext, x as RoutePostHandlerContext, R as RpcHandlerContext, f as RpcPostHandlerContext, l as createRpcDefinition, t as defineMiddleware, s as defineRoute, k as defineRpc, o as getRpcParamDefinition, n as getRpcParamName, m as getRpcPath, p as getRpcResponseName, i as isHttpMethod, j as isRpc, z as registerRoute, r as registerRpc } from './shared/arri.c20aaf19.js';
+export { d as ArriProcedure, c as ArriProcedureBase, g as ArriProcedureHandler, h as ArriProcedurePostHandler, q as ArriRoute, v as ArriRouteHandler, y as ArriRoutePostHandler, A as ArriServer, a as ArriService, E as ExtractParam, u as ExtractParams, e as HandlerContext, b as HttpMethod, H as HttpMethodValues, M as Middleware, w as RouteHandlerContext, x as RoutePostHandlerContext, R as RpcHandlerContext, f as RpcPostHandlerContext, l as createRpcDefinition, t as defineMiddleware, s as defineRoute, k as defineRpc, o as getRpcParamDefinition, n as getRpcParamName, m as getRpcPath, p as getRpcResponseName, i as isHttpMethod, j as isRpc, z as registerRoute, r as registerRpc } from './shared/arri.2ff96786.js';
 import * as _sinclair_typebox from '@sinclair/typebox';
 import { Static } from '@sinclair/typebox';
 import { ValueError } from '@sinclair/typebox/errors';

package/dist/index.mjs

@@ -1 +1 @@
-export { A as ArriServer, E as ErrorResponse, H as HttpMethodValues, v as createRpcDefinition, G as defineError, D as defineMiddleware, C as defineRoute, s as defineRpc, I as errorResponseFromValidationErrors, y as getRpcParamDefinition, x as getRpcParamName, w as getRpcPath, z as getRpcResponseName, q as isHttpMethod, m as isRpc, F as registerRoute, B as registerRpc } from './shared/arri.b4c5ce27.mjs';
+export { A as ArriServer, E as ErrorResponse, H as HttpMethodValues, z as createRpcDefinition, L as defineError, J as defineMiddleware, I as defineRoute, y as defineRpc, M as errorResponseFromValidationErrors, D as getRpcParamDefinition, C as getRpcParamName, B as getRpcPath, F as getRpcResponseName, x as isHttpMethod, o as isRpc, K as registerRoute, G as registerRpc } from './shared/arri.1f1b9dfc.mjs';

package/dist/shared/{arri.34695f7b.mjs → arri.0e69fc28.mjs}

@@ -4,11 +4,13 @@ import require$$0, { dirname } from 'path';
 import process4 from 'process';
 import require$$0$1 from 'os';
 import tty from 'tty';
-import fs$1, { realpathSync, statSync, Stats } from 'fs';
+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);
 const __filename$1 = fileURLToPath(import.meta.url);
@@ -29027,4 +29029,617 @@ var debugApis = {
   printDocToString: withPlugins(printDocToString2)
 };
 
-export { format2 as f };
+function defineClientGeneratorPlugin(plugin) {
+  return plugin;
+}
+
+const dartClientGenerator = defineClientGeneratorPlugin(
+  (options) => {
+    return {
+      generator: async (def) => {
+        if (!options.clientName) {
+          throw new Error(
+            'Missing "clientName" cannot generate dart client'
+          );
+        }
+        if (!options.outputFile) {
+          throw new Error(
+            'Missing "outputFile" cannot generate dart client'
+          );
+        }
+        const result = createDartClient(def, options.clientName);
+        writeFileSync(options.outputFile, result);
+        execSync(`dart format ${options.outputFile}`);
+      },
+      options
+    };
+  }
+);
+const generatedModels = [];
+function createDartClient(appDef, prefix = "Client") {
+  const { models, procedures } = appDef;
+  const serviceParts = [];
+  const procedureParts = [];
+  const services = unflattenProcedures(procedures);
+  Object.keys(services).forEach((k) => {
+    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) => {
+    const rpc = procedures[key];
+    endpoints[rpc.path] = rpc.method;
+  });
+  const modelParts = [];
+  Object.keys(models).forEach((key) => {
+    const model = models[key];
+    const typeName = `${prefix}${pascalCase(key)}`;
+    const objModel = model;
+    if (!generatedModels.includes(typeName)) {
+      modelParts.push(
+        dartModelFromJsonSchema(
+          `${prefix}${pascalCase(key)}`,
+          objModel
+        )
+      );
+      generatedModels.push(typeName);
+    }
+  });
+  return `// This code was autogenerated by arri. Do not modify directly.
+import "dart:convert";
+import "package:http/http.dart" as http;
+import "package:arri_client/arri_client.dart";
+
+class ${prefix} {
+  final String _baseUrl;
+  final Map<String, String> _headers;
+  const ${prefix}({
+    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,
+    );
+  }`
+  ).join("\n  ")}
+  Future<http.Response> rawRequest(
+    ${prefix}Endpoints endpoint, {
+    Map<String, String>? query,
+    dynamic body,
+    Map<String, String>? headers,
+    Encoding? encoding,
+  }) async {
+    return arriRequest(
+      "$_baseUrl\${endpoint.path}",
+      method: endpoint.method,
+      headers: headers ?? this._headers,
+      body: body,
+      query: query,
+      encoding: encoding,
+    );
+  }
+}
+${serviceParts.map((item) => item.content).join("\n")}
+${modelParts.join("\n")}
+
+enum ${prefix}Endpoints implements Comparable<${prefix}Endpoints>, ArriEndpoint {
+  ${Object.keys(endpoints).map(
+    (key) => `${camelCase(key.split("/").join("_"))}(
+        path: "${key}",
+        method: HttpMethod.${endpoints[key]},
+      )`
+  ).join(",\n  ")};
+
+  const ${prefix}Endpoints({
+    required this.path, required this.method,
+  });
+  @override
+  final String path;
+  @override
+  final HttpMethod method;
+
+  @override
+  compareTo(${prefix}Endpoints other) => name.compareTo(other.name);
+}`;
+}
+function dartServiceFromServiceDefinition(name, def, prefix = "") {
+  const rpcParts = [];
+  const subServiceParts = [];
+  const serviceName = `${name}`;
+  Object.keys(def).forEach((key) => {
+    const item = def[key];
+    if (isProcedureDefinition(item)) {
+      rpcParts.push(
+        dartProcedureFromServiceDefinition(prefix, key, item)
+      );
+      return;
+    }
+    const nameParts = name.split("Service");
+    nameParts.pop();
+    const subServiceName = pascalCase(
+      `${nameParts.join("")}_${key}_Service`
+    );
+    const subService = dartServiceFromServiceDefinition(
+      subServiceName,
+      item,
+      prefix
+    );
+    subServiceParts.push({
+      name: subServiceName,
+      key,
+      content: subService
+    });
+  });
+  return `class ${serviceName} {
+  final String _baseUrl;
+  final Map<String, String> _headers;
+  const ${serviceName}({
+    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,
+    );
+  }`
+  ).join("\n")}
+  ${rpcParts.join("\n  ")}
+}
+${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 = [];
+  Object.entries(schema.properties ?? {}).forEach(([key, val]) => {
+    if (typeof val !== "object") {
+      return;
+    }
+    const [dartType, subTypes] = dartPropertyTypeFromSchema(
+      name,
+      key,
+      schema
+    );
+    if (subTypes?.length) {
+      for (const sub of subTypes) {
+        subModelParts.push(sub);
+      }
+    }
+    fields.push({ type: dartType, name: key });
+    if (!isDartType(dartType) && "type" in val && val.type === "object") {
+      subModelParts.push(
+        dartModelFromJsonSchema(dartType.replace("?", ""), val)
+      );
+    }
+  });
+  return `class ${name} {
+  ${fields.map((field) => `final ${field.type} ${field.name};`).join("\n  ")}
+  const ${name}({
+    ${fields.map(
+    (field) => field.type.includes("?") ? `this.${field.name},` : `required this.${field.name},`
+  ).join("\n    ")}
+  });
+  factory ${name}.fromJson(Map<String, dynamic> json) {
+    return ${name}(
+      ${fields.map((field) => `${dartParsedJsonField(field.name, field.type)},`).join("\n      ")}
+    );
+  }
+  Map<String, dynamic> toJson() {
+    return {
+      ${fields.map((field) => {
+    const isNullable = field.type.endsWith("?");
+    const typeName = field.type.replace("?", "");
+    if (isDartTypeWithNullables(field.type)) {
+      const transformer = transformers[typeName];
+      return transformer.toJsonBody(field.name, isNullable);
+    }
+    if (field.type.includes("List<")) {
+      return classListTransformer(typeName).toJsonBody(
+        field.name,
+        isNullable
+      );
+    }
+    return classTransformer(typeName, isNullable).toJsonBody(
+      field.name,
+      isNullable
+    );
+  }).join(",\n      ")},
+    };
+  }
+  ${name} copyWith({
+    ${fields.map((field) => `${field.type.replace("?", "")}? ${field.name},`).join("\n    ")}
+  }) {
+    return ${name}(
+      ${fields.map((field) => `${field.name}: ${field.name} ?? this.${field.name},`).join("\n      ")}
+    );
+  }
+}
+
+${subModelParts.join("\n")}`;
+}
+function dartPropertyTypeFromSchema(objectName, propertyName, schema) {
+  const prop = schema.properties?.[propertyName];
+  const isOptional = !schema.required?.includes(propertyName);
+  let finalType = "";
+  const subTypes = [];
+  if (isJsonSchemaEnum(prop)) {
+    const enumName = pascalCase(`${objectName}_${propertyName}`);
+    finalType = isOptional ? `${enumName}?` : enumName;
+    const options = [];
+    for (const opt of prop.anyOf) {
+      if (opt.type === "string") {
+        options.push({
+          name: camelCase(opt.const.toString()),
+          type: "String",
+          value: opt.const
+        });
+      }
+      if (opt.type === "number" || opt.type === "integer") {
+        options.push({
+          name: camelCase(
+            `num_${opt.const}`.split(".").join("Point")
+          ),
+          type: opt.type === "number" ? "double" : "int",
+          value: opt.const
+        });
+      }
+    }
+    subTypes.push(`enum ${enumName} implements Comparable<${enumName}> {
+  ${options.map(
+      (opt) => `${opt.name}(${opt.type === "String" ? `"${opt.value}"` : opt.value})`
+    ).join(",\n  ")};
+  const ${enumName}(this.value);
+  final dynamic value;
+
+  @override
+  compareTo(${enumName} other) => name.compareTo(other.name);
+
+  factory ${enumName}.fromJson(dynamic input) {
+    for(final val in values) {
+      if(val.value == input) {
+        return val;
+      }
+    }
+    return ${options[0].name};
+  }
+
+  dynamic toJson() {
+    return value;
+  }
+}`);
+    return [finalType, subTypes];
+  }
+  if (isJsonSchemaNullType(prop)) {
+    finalType = "null";
+    return [finalType, subTypes];
+  }
+  if (isJsonSchemaScalarType(prop)) {
+    switch (prop.type) {
+      case "string":
+        finalType = isOptional ? "String?" : "String";
+        break;
+      case "integer":
+        finalType = isOptional ? "int?" : "int";
+        break;
+      case "number":
+        finalType = isOptional ? "double?" : "double";
+        break;
+      case "Date":
+        finalType = isOptional ? "DateTime?" : "DateTime";
+        break;
+      case "boolean":
+        finalType = isOptional ? "bool?" : "bool";
+        break;
+    }
+  }
+  if (isJsonSchemaObject(prop)) {
+    const joinedPropName = pascalCase(
+      `${objectName}_${propertyName}`
+    );
+    finalType = isOptional ? `${joinedPropName}?` : joinedPropName;
+  }
+  if (isJsonSchemaArray(prop)) {
+    const item = prop.items;
+    const type = item.type;
+    if (typeof type !== "string") {
+      throw new Error(
+        "Union types are not supported in arrays at this time"
+      );
+    }
+    switch (type) {
+      case "string":
+        finalType = isOptional ? "List<String>?" : "List<String>";
+        break;
+      case "integer":
+        finalType = isOptional ? "List<int>?" : "List<int>";
+        break;
+      case "number":
+        finalType = isOptional ? "List<double>?" : "List<double>";
+        break;
+      case "null":
+        finalType = isOptional ? "List<null>?" : "List<null>";
+        break;
+      case "boolean":
+        finalType = isOptional ? "List<bool>?" : "List<bool>";
+        break;
+      case "Date":
+        finalType = isOptional ? "List<DateTime>?" : "List<DateTime>";
+        break;
+      case "object": {
+        const subTypeName = item.$id ?? pascalCase(`${objectName}_${propertyName}_item`);
+        const model = dartModelFromJsonSchema(subTypeName, item);
+        if (!generatedModels.includes(subTypeName)) {
+          subTypes.push(model);
+          generatedModels.push(subTypeName);
+        }
+        finalType = isOptional ? `List<${subTypeName}>?` : `List<${subTypeName}>`;
+        break;
+      }
+    }
+  }
+  return [finalType, subTypes.length ? subTypes : void 0];
+}
+function dartParsedJsonField(fieldName, dartType) {
+  if (isDartTypeWithNullables(dartType)) {
+    switch (dartType) {
+      case "String":
+        return transformers.String.fromJsonBody(fieldName, '""');
+      case "String?":
+        return transformers.String.fromJsonBody(fieldName, "null");
+      case "bool":
+        return transformers.bool.fromJsonBody(fieldName, "false");
+      case "double":
+        return transformers.double.fromJsonBody(fieldName, "0.0");
+      case "int":
+        return transformers.int.fromJsonBody(fieldName, "0");
+      case "null":
+        return transformers.null.fromJsonBody(fieldName, "");
+      case "DateTime":
+        return transformers.DateTime.fromJsonBody(
+          fieldName,
+          "DateTime(0)"
+        );
+      case "DateTime?":
+        return transformers.DateTime.fromJsonBody(fieldName, "null");
+      case "List<String>":
+      case "List<bool>":
+      case "List<double>":
+      case "List<int>":
+      case "List<null>":
+        return defaultListFromJsonBody(
+          fieldName,
+          dartType.replace("List<", "").replace(">", ""),
+          "[]"
+        );
+      default:
+        return `${fieldName}: json["${fieldName}"] is ${dartType.replace(
+          "?",
+          ""
+        )} ? json["${fieldName}"] : null`;
+    }
+  }
+  if (dartType.includes("List<")) {
+    const innerType = dartType.replace("List<", "").replace(">", "").replace("?", "");
+    return classListTransformer(innerType).fromJsonBody(
+      fieldName,
+      dartType.endsWith("?") ? "null" : "[]"
+    );
+  }
+  const classType = dartType.split("?").join("").trim();
+  return classTransformer(classType, dartType.endsWith("?")).fromJsonBody(
+    fieldName,
+    classType
+  );
+}
+const dartTypeMap = {
+  integer: "int",
+  bigint: "int",
+  number: "double",
+  string: "String",
+  boolean: "bool",
+  null: "null",
+  Date: "DateTime",
+  object: void 0,
+  list: void 0,
+  // eslint-disable-next-line object-shorthand
+  undefined: void 0,
+  array: void 0,
+  Uint8Array: "Uint8List"
+};
+const transformers = {
+  null: {
+    fromJsonBody: (_) => `null`,
+    toJsonBody: defaultToJsonBody
+  },
+  int: {
+    fromJsonBody: (key, fallback) => defaultFromJsonBody(key, "int", fallback),
+    toJsonBody: defaultToJsonBody
+  },
+  double: {
+    fromJsonBody: (key, fallback) => defaultFromJsonBody(key, "double", fallback),
+    toJsonBody: defaultToJsonBody
+  },
+  String: {
+    fromJsonBody: (key, fallback) => defaultFromJsonBody(key, "String", fallback),
+    toJsonBody: defaultToJsonBody
+  },
+  bool: {
+    fromJsonBody: (key, fallback) => defaultFromJsonBody(key, "bool", fallback),
+    toJsonBody: defaultToJsonBody
+  },
+  DateTime: {
+    fromJsonBody: (key, fallback) => `${key}: json["${key}"] is String ? DateTime.parse(json["${key}"]) : ${fallback}`,
+    toJsonBody: (key, isNullable) => `"${key}": ${key}${isNullable ? "?" : ""}.toIso8601String()`
+  },
+  "List<null>": {
+    fromJsonBody: (key, fallback) => defaultListFromJsonBody(key, "null", fallback),
+    toJsonBody: defaultToJsonBody
+  },
+  "List<int>": {
+    fromJsonBody: (key, fallback) => defaultListFromJsonBody(key, "int", fallback),
+    toJsonBody: defaultToJsonBody
+  },
+  "List<double>": {
+    fromJsonBody: (key, fallback) => defaultListFromJsonBody(key, "double", fallback),
+    toJsonBody: defaultToJsonBody
+  },
+  "List<String>": {
+    fromJsonBody: (key, fallback) => defaultListFromJsonBody(key, "String", fallback),
+    toJsonBody: defaultToJsonBody
+  },
+  "List<bool>": {
+    fromJsonBody: (key, fallback) => defaultListFromJsonBody(key, "bool", fallback),
+    toJsonBody: defaultToJsonBody
+  },
+  "List<DateTime>": {
+    fromJsonBody: (key, fallback) => `${key}: json["${key}"] is List<String> ?
+            (json["${key}"] as List<String>)
+                .map((item) => DateTime.parse(item)).toList() : ${fallback}`,
+    toJsonBody: (key, isNullable) => `"${key}": ${key}${isNullable ? "?" : ""}.map((val) => val.toIso8601String()).toList()`
+  },
+  Uint8List: {
+    fromJsonBody: (key, fallback) => `${key}: json["${key}"] is List ? Uint8List.fromList(json["${key}"]) : ${fallback}`,
+    toJsonBody: (key, isNullable) => `"${key}": ${key}${isNullable ? "?" : ""}.toList()`
+  },
+  "List<Uint8List>": {
+    fromJsonBody: (key, fallback) => `${key}: json["${key}"] is List && (json["${key}"] as List).isNotEmpty && (json["${key}"] as List).first is List ? json["${key}"] : ${fallback}`,
+    toJsonBody: (key, isNullable) => `"${key}": ${key}${isNullable ? "?" : ""}.map((val) => val.toList()).toList()`
+  }
+};
+function defaultFromJsonBody(key, typename, fallback) {
+  return `${key}: json["${key}"] is ${typename} ? json["${key}"] : ${fallback}`;
+}
+function defaultListFromJsonBody(key, typename, fallback) {
+  return `${key}: json["${key}"] is List<${typename}> ? json["${key}"] : ${fallback}`;
+}
+function defaultToJsonBody(key) {
+  return `"${key}": ${key}`;
+}
+const classTransformer = (typename, nullable) => {
+  return {
+    fromJsonBody: (key, fallback) => {
+      if (nullable) {
+        return `${key}: json["${key}"] is Map<String, dynamic> ? 
+                ${typename}.fromJson(json["${key}"]) : null`;
+      }
+      return `${key}: ${typename}.fromJson(json["${key}"])`;
+    },
+    toJsonBody: (key, isNullable) => `"${key}": ${key}${isNullable ? "?" : ""}.toJson()`
+  };
+};
+const classListTransformer = (typename) => {
+  return {
+    fromJsonBody: (key, fallback) => {
+      return `${key}: json["${key}"] is List<Map<String, dynamic>> ? 
+                (json["${key}"] as List<Map<String, dynamic>>)
+                    .map((val) => ${typename}.fromJson(val)).toList() : ${fallback}`;
+    },
+    toJsonBody: (key, isNullable) => `"${key}": ${key}${isNullable ? "?" : ""}.map((val) => val.toJson()).toList()`
+  };
+};
+function isDartType(input) {
+  if (typeof input !== "string") {
+    return false;
+  }
+  for (const val of Object.values(dartTypeMap)) {
+    if (input === val) {
+      return true;
+    }
+    if (input.replace("List<", "").replace(">", "") === val) {
+      return true;
+    }
+  }
+  return false;
+}
+function isDartTypeWithNullables(input) {
+  if (typeof input !== "string") {
+    return false;
+  }
+  for (const val of Object.values(dartTypeMap)) {
+    if (input.replace("?", "") === val) {
+      return true;
+    }
+    if (input.replace("?", "").replace("List<", "").replace(">", "") === val) {
+      return true;
+    }
+  }
+  return false;
+}
+
+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 };