arri 0.0.15 → 0.0.16

package/dist/shared/arri.0671bb8c.mjs

@@ -0,0 +1,641 @@
+import { execSync } from 'child_process';
+import { writeFileSync } from 'fs';
+import { y as unflattenProcedures, o as isServiceDef, p as pascalCase, z as camelCase, q as isProcedureDef, v as isJsonSchemaObject, w as isJsonSchemaEnum, t as isJsonSchemaNullType, s as isJsonSchemaScalarType, x as isJsonSchemaArray } from './arri.fd713b2e.mjs';
+
+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, {
+          clientName: options.clientName
+        });
+        writeFileSync(options.outputFile, result);
+        try {
+          execSync(`dart format ${options.outputFile}`);
+        } catch (err) {
+          console.error("Error formatting dart client", err);
+        }
+      },
+      options
+    };
+  }
+);
+let generatedModels = [];
+function createDartClient(appDef, opts = { clientName: "Client" }) {
+  generatedModels = [];
+  const { models, procedures } = appDef;
+  const serviceParts = [];
+  const procedureParts = [];
+  const services = unflattenProcedures(procedures);
+  Object.keys(services).forEach((k) => {
+    const item = services[k];
+    if (isServiceDef(item)) {
+      const serviceName = pascalCase(`${opts.clientName}_${k}_service`);
+      serviceParts.push({
+        name: serviceName,
+        key: k,
+        content: dartServiceFromServiceDefinition(
+          // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+          serviceName,
+          item)
+      });
+      return;
+    }
+    procedureParts.push(dartProcedureFromServiceDefinition(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 = pascalCase(key);
+    const objModel = model;
+    if (!generatedModels.includes(typeName)) {
+      modelParts.push(
+        dartModelFromJsonSchema(`${pascalCase(key)}`, objModel)
+      );
+      generatedModels.push(typeName);
+    }
+  });
+  return `// This code was autogenerated by Arri. Do not modify directly.
+// For additional documentation visit http://github.com/modiimedia/arri
+import "dart:convert";
+import "package:arri_client/arri_client.dart";
+
+class ${opts.clientName} {
+  final String _baseUrl;
+  final Map<String, String> _headers;
+  const ${opts.clientName}({
+    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  ")}
+}
+${serviceParts.map((item) => item.content).join("\n")}
+${modelParts.join("\n")}
+
+enum ${opts.clientName}Endpoints implements Comparable<${opts.clientName}Endpoints>, ArriEndpoint {
+  ${Object.keys(endpoints).map(
+    (key) => `${camelCase(key.split("/").join("_"))}(
+        path: "${key}",
+        method: HttpMethod.${endpoints[key]},
+      )`
+  ).join(",\n  ")};
+
+  const ${opts.clientName}Endpoints({
+    required this.path, required this.method,
+  });
+  @override
+  final String path;
+  @override
+  final HttpMethod method;
+
+  @override
+  compareTo(${opts.clientName}Endpoints other) => name.compareTo(other.name);
+}`;
+}
+function dartServiceFromServiceDefinition(name, def, opts) {
+  const rpcParts = [];
+  const subServiceParts = [];
+  const serviceName = `${name}`;
+  Object.keys(def).forEach((key) => {
+    const item = def[key];
+    if (isProcedureDef(item)) {
+      rpcParts.push(dartProcedureFromServiceDefinition(key, item));
+      return;
+    }
+    const nameParts = name.split("Service");
+    nameParts.pop();
+    const subServiceName = pascalCase(
+      `${nameParts.join("")}_${key}_Service`
+    );
+    const subService = dartServiceFromServiceDefinition(
+      subServiceName,
+      item);
+    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(key, def, opts) {
+  let returnType = `Future<String>`;
+  let returnTypeName = "String";
+  if (def.response) {
+    returnType = `Future<${def.response}>`;
+    returnTypeName = `${def.response}`;
+  } else {
+    returnType = "Future<void>";
+  }
+  let paramsInput = "";
+  if (def.params) {
+    paramsInput = `${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(modelName, schema, opts) {
+  const modelDisplayName = pascalCase(`${modelName}`);
+  const fields = [];
+  const subModelParts = [];
+  Object.entries(schema.properties ?? {}).forEach(([key, val]) => {
+    if (typeof val !== "object") {
+      return;
+    }
+    const [dartType, subTypes] = dartPropertyTypeFromSchema(
+      modelName,
+      key,
+      schema);
+    if (subTypes?.length) {
+      for (const sub of subTypes) {
+        subModelParts.push(sub);
+      }
+    }
+    fields.push({ type: dartType, name: camelCase(key), jsonKey: key });
+    if (!isDartType(dartType) && isJsonSchemaObject(val)) {
+      if (val.$id && generatedModels.includes(val.$id)) {
+        return;
+      }
+      const subModelName = val.$id ? pascalCase(val.$id) : pascalCase(dartType.replace("?", ""));
+      subModelParts.push(
+        dartModelFromJsonSchema(subModelName, val)
+      );
+      generatedModels.push(subModelName);
+    }
+  });
+  return `class ${modelDisplayName} {
+  ${fields.map((field) => `final ${field.type} ${field.name};`).join("\n  ")}
+  const ${modelDisplayName}({
+    ${fields.map(
+    (field) => field.type.includes("?") ? `this.${field.name},` : `required this.${field.name},`
+  ).join("\n    ")}
+  });
+  factory ${modelDisplayName}.fromJson(Map<String, dynamic> json) {
+    return ${modelDisplayName}(
+      ${fields.map(
+    (field) => `${dartParsedJsonField(
+      field.name,
+      field.jsonKey,
+      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,
+        field.jsonKey,
+        isNullable
+      );
+    }
+    if (field.type.includes("List<")) {
+      return classListTransformer(typeName).toJsonBody(
+        field.name,
+        field.jsonKey,
+        isNullable
+      );
+    }
+    return classTransformer(typeName, isNullable).toJsonBody(
+      field.name,
+      field.jsonKey,
+      isNullable
+    );
+  }).join(",\n      ")},
+    };
+  }
+  ${modelDisplayName} copyWith({
+    ${fields.map((field) => `${field.type.replace("?", "")}? ${field.name},`).join("\n    ")}
+  }) {
+    return ${modelDisplayName}(
+      ${fields.map((field) => `${field.name}: ${field.name} ?? this.${field.name},`).join("\n      ")}
+    );
+  }
+}
+
+${subModelParts.join("\n")}`;
+}
+function dartPropertyTypeFromSchema(objectName, propertyName, schema, opts) {
+  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 = prop.$id ? pascalCase(prop.$id) : 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`);
+        if (!generatedModels.includes(subTypeName)) {
+          const model = dartModelFromJsonSchema(
+            subTypeName,
+            item);
+          subTypes.push(model);
+          generatedModels.push(subTypeName);
+        }
+        finalType = isOptional ? `List<${subTypeName}>?` : `List<${subTypeName}>`;
+        break;
+      }
+    }
+  }
+  return [finalType, subTypes.length ? subTypes : void 0];
+}
+function dartParsedJsonField(fieldName, jsonKey, dartType) {
+  if (isDartTypeWithNullables(dartType)) {
+    switch (dartType) {
+      case "String":
+        return transformers.String.fromJsonBody(
+          fieldName,
+          jsonKey,
+          '""'
+        );
+      case "String?":
+        return transformers.String.fromJsonBody(
+          fieldName,
+          jsonKey,
+          "null"
+        );
+      case "bool":
+        return transformers.bool.fromJsonBody(
+          fieldName,
+          jsonKey,
+          "false"
+        );
+      case "double":
+        return transformers.double.fromJsonBody(
+          fieldName,
+          jsonKey,
+          "0.0"
+        );
+      case "int":
+        return transformers.int.fromJsonBody(fieldName, jsonKey, "0");
+      case "null":
+        return transformers.null.fromJsonBody(fieldName, jsonKey, "");
+      case "DateTime":
+        return transformers.DateTime.fromJsonBody(
+          fieldName,
+          jsonKey,
+          "DateTime(0)"
+        );
+      case "DateTime?":
+        return transformers.DateTime.fromJsonBody(
+          fieldName,
+          jsonKey,
+          "null"
+        );
+      case "List<String>":
+      case "List<bool>":
+      case "List<double>":
+      case "List<int>":
+      case "List<null>":
+        return defaultListFromJsonBody(
+          fieldName,
+          jsonKey,
+          dartType.replace("List<", "").replace(">", ""),
+          "[]"
+        );
+      default:
+        return `${fieldName}: json["${jsonKey}"] is ${dartType.replace(
+          "?",
+          ""
+        )} ? json["${jsonKey}"] : null`;
+    }
+  }
+  if (dartType.includes("List<")) {
+    const innerType = dartType.replace("List<", "").replace(">", "").replace("?", "");
+    return classListTransformer(innerType).fromJsonBody(
+      fieldName,
+      jsonKey,
+      dartType.endsWith("?") ? "null" : "[]"
+    );
+  }
+  const classType = dartType.split("?").join("").trim();
+  return classTransformer(classType, dartType.endsWith("?")).fromJsonBody(
+    fieldName,
+    jsonKey,
+    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, jsonKey, fallback) => defaultFromJsonBody(key, jsonKey, "int", fallback),
+    toJsonBody: defaultToJsonBody
+  },
+  double: {
+    fromJsonBody: (key, jsonKey, fallback) => defaultFromJsonBody(key, jsonKey, "double", fallback),
+    toJsonBody: defaultToJsonBody
+  },
+  String: {
+    fromJsonBody: (key, jsonKey, fallback) => defaultFromJsonBody(key, jsonKey, "String", fallback),
+    toJsonBody: defaultToJsonBody
+  },
+  bool: {
+    fromJsonBody: (key, jsonKey, fallback) => defaultFromJsonBody(key, jsonKey, "bool", fallback),
+    toJsonBody: defaultToJsonBody
+  },
+  DateTime: {
+    fromJsonBody: (key, jsonKey, fallback) => `${key}: json["${jsonKey}"] is String ? DateTime.parse(json["${jsonKey}"]) : ${fallback}`,
+    toJsonBody: (key, jsonKey, isNullable) => `"${jsonKey}": ${key}${isNullable ? "?" : ""}.toIso8601String()`
+  },
+  "List<null>": {
+    fromJsonBody: (key, jsonKey, fallback) => defaultListFromJsonBody(key, jsonKey, "null", fallback),
+    toJsonBody: defaultToJsonBody
+  },
+  "List<int>": {
+    fromJsonBody: (key, jsonKey, fallback) => defaultListFromJsonBody(key, jsonKey, "int", fallback),
+    toJsonBody: defaultToJsonBody
+  },
+  "List<double>": {
+    fromJsonBody: (key, jsonKey, fallback) => defaultListFromJsonBody(key, jsonKey, "double", fallback),
+    toJsonBody: defaultToJsonBody
+  },
+  "List<String>": {
+    fromJsonBody: (key, jsonKey, fallback) => defaultListFromJsonBody(key, jsonKey, "String", fallback),
+    toJsonBody: defaultToJsonBody
+  },
+  "List<bool>": {
+    fromJsonBody: (key, jsonKey, fallback) => defaultListFromJsonBody(key, jsonKey, "bool", fallback),
+    toJsonBody: defaultToJsonBody
+  },
+  "List<DateTime>": {
+    fromJsonBody: (key, jsonKey, fallback) => `${key}: json["${jsonKey}"] is List<String> ?
+            (json["${jsonKey}"] as List<String>)
+                .map((item) => DateTime.parse(item)).toList() : ${fallback}`,
+    toJsonBody: (key, jsonKey, isNullable) => `"${jsonKey}": ${key}${isNullable ? "?" : ""}.map((val) => val.toIso8601String()).toList()`
+  },
+  Uint8List: {
+    fromJsonBody: (key, jsonKey, fallback) => `${key}: json["${jsonKey}"] is List ? Uint8List.fromList(json["${jsonKey}"]) : ${fallback}`,
+    toJsonBody: (key, jsonKey, isNullable) => `"${jsonKey}": ${key}${isNullable ? "?" : ""}.toList()`
+  },
+  "List<Uint8List>": {
+    fromJsonBody: (key, jsonKey, fallback) => `${key}: json["${jsonKey}"] is List && (json["${jsonKey}"] as List).isNotEmpty && (json["${jsonKey}"] as List).first is List ? json["${jsonKey}"] : ${fallback}`,
+    toJsonBody: (key, jsonKey, isNullable) => `"${jsonKey}": ${key}${isNullable ? "?" : ""}.map((val) => val.toList()).toList()`
+  }
+};
+function defaultFromJsonBody(key, jsonKey, typename, fallback) {
+  return `${key}: json["${jsonKey}"] is ${typename} ? json["${jsonKey}"] : ${fallback}`;
+}
+function defaultListFromJsonBody(key, jsonKey, typename, fallback) {
+  return `${key}: json["${jsonKey}"] is List<${typename}> ? json["${jsonKey}"] : ${fallback}`;
+}
+function defaultToJsonBody(key, jsonKey) {
+  return `"${jsonKey}": ${key}`;
+}
+const classTransformer = (typename, nullable) => {
+  return {
+    fromJsonBody: (key, jsonKey, fallback) => {
+      if (nullable) {
+        return `${key}: json["${jsonKey}"] is Map<String, dynamic> ? 
+                ${typename}.fromJson(json["${jsonKey}"]) : null`;
+      }
+      return `${key}: ${typename}.fromJson(json["${jsonKey}"])`;
+    },
+    toJsonBody: (key, jsonKey, isNullable) => {
+      return `"${jsonKey}": ${key}${isNullable ? "?" : ""}.toJson()`;
+    }
+  };
+};
+const classListTransformer = (typename) => {
+  return {
+    fromJsonBody: (key, jsonKey, fallback) => {
+      return `${key}: json["${jsonKey}"] is List<Map<String, dynamic>> ? 
+                (json["${jsonKey}"] as List<Map<String, dynamic>>)
+                    .map((val) => ${typename}.fromJson(val)).toList() : ${fallback}`;
+    },
+    toJsonBody: (key, jsonKey, isNullable) => `"${jsonKey}": ${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, dartModelFromJsonSchema as f, dartPropertyTypeFromSchema as g, dartParsedJsonField as h, classTransformer as i, classListTransformer as j, isDartType as k, isDartTypeWithNullables as l, transformers as t };