arri 0.0.6 → 0.0.7

package/dist/shared/{arri.38ad6cd0.cjs → arri.835c5c3c.cjs}

@@ -11,6 +11,8 @@ const assert4 = require('assert');
 const fs = require('fs/promises');
 const v8 = require('v8');
 const require$$0$1 = require('util');
+const index = require('./arri.8e602d87.cjs');
+const require$$1 = require('child_process');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 
@@ -23,8 +25,8 @@ const assert4__default = /*#__PURE__*/_interopDefaultCompat(assert4);
 const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
 const v8__default = /*#__PURE__*/_interopDefaultCompat(v8);
 
-const require$2 = require$$2.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (document.currentScript && document.currentScript.src || new URL('shared/arri.38ad6cd0.cjs', document.baseURI).href)));
-const __filename$2 = require$$7.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (document.currentScript && document.currentScript.src || new URL('shared/arri.38ad6cd0.cjs', document.baseURI).href)));
+const require$2 = require$$2.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (document.currentScript && document.currentScript.src || new URL('shared/arri.835c5c3c.cjs', document.baseURI).href)));
+const __filename$2 = require$$7.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (document.currentScript && document.currentScript.src || new URL('shared/arri.835c5c3c.cjs', document.baseURI).href)));
 const __dirname$1 = require$$0.dirname(__filename$2);
 
 var __create$1 = Object.create;
@@ -7789,8 +7791,8 @@ const doc = {
   utils: utils
 };
 
-const require$1 = require$$2.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (document.currentScript && document.currentScript.src || new URL('shared/arri.38ad6cd0.cjs', document.baseURI).href)));
-const __filename$1 = require$$7.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (document.currentScript && document.currentScript.src || new URL('shared/arri.38ad6cd0.cjs', document.baseURI).href)));
+const require$1 = require$$2.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (document.currentScript && document.currentScript.src || new URL('shared/arri.835c5c3c.cjs', document.baseURI).href)));
+const __filename$1 = require$$7.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (document.currentScript && document.currentScript.src || new URL('shared/arri.835c5c3c.cjs', document.baseURI).href)));
 require$$0.dirname(__filename$1);
 
 var __create = Object.create;
@@ -29040,4 +29042,630 @@ var debugApis = {
   printDocToString: withPlugins(printDocToString2)
 };
 
+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);
+        fs$1.writeFileSync(options.outputFile, result);
+        require$$1.execSync(`dart format ${options.outputFile}`);
+      },
+      options
+    };
+  }
+);
+const generatedModels = [];
+function createDartClient(appDef, prefix = "Client") {
+  const { models, procedures } = appDef;
+  const serviceParts = [];
+  const procedureParts = [];
+  const services = index.unflattenProcedures(procedures);
+  Object.keys(services).forEach((k) => {
+    const item = services[k];
+    if (index.isServiceDefinition(item)) {
+      const serviceName = index.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}${index.pascalCase(key)}`;
+    const objModel = model;
+    if (!generatedModels.includes(typeName)) {
+      modelParts.push(
+        dartModelFromJsonSchema(
+          `${prefix}${index.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) => `${index.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 (index.isProcedureDefinition(item)) {
+      rpcParts.push(
+        dartProcedureFromServiceDefinition(prefix, key, item)
+      );
+      return;
+    }
+    const nameParts = name.split("Service");
+    nameParts.pop();
+    const subServiceName = index.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 (index.isJsonSchemaEnum(prop)) {
+    const enumName = index.pascalCase(`${objectName}_${propertyName}`);
+    finalType = isOptional ? `${enumName}?` : enumName;
+    const options = [];
+    for (const opt of prop.anyOf) {
+      if (opt.type === "string") {
+        options.push({
+          name: index.camelCase(opt.const.toString()),
+          type: "String",
+          value: opt.const
+        });
+      }
+      if (opt.type === "number" || opt.type === "integer") {
+        options.push({
+          name: index.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 (index.isJsonSchemaNullType(prop)) {
+    finalType = "null";
+    return [finalType, subTypes];
+  }
+  if (index.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 (index.isJsonSchemaObject(prop)) {
+    const joinedPropName = index.pascalCase(
+      `${objectName}_${propertyName}`
+    );
+    finalType = isOptional ? `${joinedPropName}?` : joinedPropName;
+  }
+  if (index.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 ?? index.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;
+}
+
+exports.classListTransformer = classListTransformer;
+exports.classTransformer = classTransformer;
+exports.createDartClient = createDartClient;
+exports.dartClientGenerator = dartClientGenerator;
+exports.dartModelFromJsonSchema = dartModelFromJsonSchema;
+exports.dartParsedJsonField = dartParsedJsonField;
+exports.dartProcedureFromServiceDefinition = dartProcedureFromServiceDefinition;
+exports.dartPropertyTypeFromSchema = dartPropertyTypeFromSchema;
+exports.dartServiceFromServiceDefinition = dartServiceFromServiceDefinition;
+exports.defineClientGeneratorPlugin = defineClientGeneratorPlugin;
 exports.format2 = format2;
+exports.isDartType = isDartType;
+exports.isDartTypeWithNullables = isDartTypeWithNullables;
+exports.transformers = transformers;