arri 0.0.38 → 0.0.42

package/dist/shared/arri.4536bc49.d.ts

@@ -0,0 +1,77 @@
+import { TObject } from '@sinclair/typebox';
+
+declare const HttpMethodValues: readonly ["get", "post", "put", "patch", "delete", "head"];
+type HttpMethod = (typeof HttpMethodValues)[number];
+
+declare const JsonSchemaScalarTypeValues: readonly ["integer", "number", "bigint", "string", "boolean", "Date"];
+declare const JsonSchemaNullTypeValues: readonly ["null", "undefined"];
+type JsonSchemaType = JsonSchemaScalarType | JsonSchemaNullType | JsonSchemaComplexType;
+interface JsonSchemaTypeBase {
+    $id?: string;
+    title?: string;
+    description?: string;
+}
+interface JsonSchemaScalarType extends JsonSchemaTypeBase {
+    type: (typeof JsonSchemaScalarTypeValues)[number];
+}
+interface JsonSchemaNullType extends JsonSchemaTypeBase {
+    type: (typeof JsonSchemaNullTypeValues)[number];
+}
+type JsonSchemaComplexType = JsonSchemaObject | JsonSchemaArray | JsonSchemaRecord;
+interface JsonSchemaObject extends JsonSchemaTypeBase {
+    type: "object";
+    properties: Record<string, JsonSchemaType>;
+    required?: string[];
+    additionalProperties?: boolean;
+}
+interface JsonSchemaRecord extends JsonSchemaTypeBase {
+    type: "object";
+    patternProperties: Record<string, JsonSchemaType>;
+}
+interface JsonSchemaArray extends JsonSchemaTypeBase {
+    type: "array";
+    items: JsonSchemaType;
+}
+
+interface ApplicationDef {
+    arriSchemaVersion: "0.0.1";
+    info?: {
+        title?: string;
+        description?: string;
+        version?: string;
+    };
+    externalDocs?: {
+        description?: string;
+        url: string;
+    };
+    procedures: Record<string, ProcedureDef>;
+    models: Record<string, JsonSchemaObject>;
+    errors: Omit<TObject, symbol>;
+}
+declare function normalizeWhitespace(input: string): string;
+interface ProcedureDef {
+    path: string;
+    description?: string;
+    method: HttpMethod;
+    params: string | undefined;
+    response: string | undefined;
+}
+declare function isProcedureDef(input: any): input is ProcedureDef;
+interface ServiceDef {
+    [key: string]: ProcedureDef | ServiceDef;
+}
+declare function isServiceDef(input: any): input is ServiceDef;
+declare function isApplicationDef(input: any): input is ApplicationDef;
+declare function unflattenObject(data: Record<string, any>): any;
+declare function unflattenProcedures(procedures: ApplicationDef["procedures"]): Record<string, ProcedureDef | ServiceDef>;
+declare function setNestedObjectProperty<T>(targetProp: string, value: T, object: Record<any, any>): Record<any, any>;
+declare const removeDisallowedChars: (input: string, disallowedChars: string) => string;
+
+interface ClientGenerator<TOptions extends Record<string, any> | undefined> {
+    generator: (def: ApplicationDef) => any;
+    options: TOptions;
+}
+type ClientGeneratorPlugin<TOptions extends Record<string, any> | undefined> = (options: TOptions) => ClientGenerator<TOptions>;
+declare function defineClientGeneratorPlugin<TOptions extends Record<string, any> | undefined>(plugin: ClientGeneratorPlugin<TOptions>): ClientGeneratorPlugin<TOptions>;
+
+export { type ApplicationDef as A, type ClientGeneratorPlugin as C, type HttpMethod as H, type JsonSchemaObject as J, type ProcedureDef as P, type ServiceDef as S, type ClientGenerator as a, isServiceDef as b, isApplicationDef as c, defineClientGeneratorPlugin as d, unflattenProcedures as e, isProcedureDef as i, normalizeWhitespace as n, removeDisallowedChars as r, setNestedObjectProperty as s, unflattenObject as u };

package/dist/shared/{arri.1a30c6b5.mjs → arri.b38c19c1.mjs}

@@ -1,11 +1,83 @@
 import { execSync } from 'child_process';
 import { writeFileSync } from 'fs';
-import { h as unflattenProcedures, i as isServiceDef, p as pascalCase, j as camelCase, a as isProcedureDef, d as isJsonSchemaObject, f as isJsonSchemaEnum, c as isJsonSchemaNullType, b as isJsonSchemaScalarType, e as isJsonSchemaRecord, g as isJsonSchemaArray } from './arri.f1c922a6.mjs';
+import { b as unflattenProcedures, i as isServiceDef, p as pascalCase, c as camelCase, a as isProcedureDef } from './arri.ebf86912.mjs';
 
 function defineClientGeneratorPlugin(plugin) {
   return plugin;
 }
 
+const JsonSchemaScalarTypeValues = [
+  "integer",
+  "number",
+  "bigint",
+  "string",
+  "boolean",
+  "Date"
+];
+const JsonSchemaNullTypeValues = ["null", "undefined"];
+function isJsonSchemaScalarType(input) {
+  if (typeof input !== "object") {
+    return false;
+  }
+  if (!("type" in input)) {
+    return false;
+  }
+  return JsonSchemaScalarTypeValues.includes(input.type);
+}
+function isJsonSchemaNullType(input) {
+  if (typeof input !== "object") {
+    return false;
+  }
+  if (!("type" in input)) {
+    return false;
+  }
+  return JsonSchemaNullTypeValues.includes(input.type);
+}
+const isJsonSchemaObject = (input) => {
+  if (typeof input !== "object") {
+    return false;
+  }
+  return "type" in input && input.type === "object" && "properties" in input && typeof input.properties === "object";
+};
+const isJsonSchemaRecord = (input) => {
+  if (typeof input !== "object") {
+    return false;
+  }
+  return "type" in input && input.type === "object" && "patternProperties" in input && typeof input.patternProperties === "object";
+};
+function isJsonSchemaArray(input) {
+  if (typeof input !== "object") {
+    return false;
+  }
+  if ("type" in input && input.type === "array") {
+    return true;
+  }
+  return false;
+}
+function isJsonSchemaEnum(input) {
+  if (typeof input !== "object") {
+    return false;
+  }
+  if (!("anyOf" in input) || !Array.isArray(input.anyOf)) {
+    return false;
+  }
+  let prevType;
+  for (const item of input.anyOf) {
+    if (!isJsonSchemaScalarType(item)) {
+      return false;
+    }
+    if (item.type !== "string" && item.type !== "integer" && item.type !== "number") {
+      return false;
+    }
+    if (!prevType) {
+      prevType = item.type;
+    } else if (prevType !== item.type) {
+      return false;
+    }
+  }
+  return true;
+}
+
 const dartClientGenerator = defineClientGeneratorPlugin(
   (options) => {
     return {
@@ -276,6 +348,9 @@ function dartModelFromJsonSchema(modelName, schema, opts) {
       ${fields.map((field) => {
     const isNullable = field.type.endsWith("?");
     const typeName = field.type.replace("?", "");
+    if (typeName === "dynamic") {
+      return `"${field.jsonKey}": ${field.name}`;
+    }
     if (isDartTypeWithNullables(field.type)) {
       const transformer = transformers[typeName];
       return transformer.toJsonBody(
@@ -303,7 +378,9 @@ function dartModelFromJsonSchema(modelName, schema, opts) {
     };
   }
   ${modelDisplayName} copyWith({
-    ${fields.map((field) => `${field.type.replace("?", "")}? ${field.name},`).join("\n    ")}
+    ${fields.map(
+    (field) => `${field.type.replace("?", "")}${field.type !== "dynamic" ? "?" : ""} ${field.name},`
+  ).join("\n    ")}
   }) {
     return ${modelDisplayName}(
       ${fields.map((field) => `${field.name}: ${field.name} ?? this.${field.name},`).join("\n      ")}
@@ -316,7 +393,7 @@ ${subModelParts.join("\n")}`;
 function dartPropertyTypeFromSchema(objectName, propertyName, schema, opts) {
   const prop = schema.properties?.[propertyName];
   const isOptional = !schema.required?.includes(propertyName);
-  let finalType = "";
+  let finalType = "dynamic";
   const subTypes = [];
   if (isJsonSchemaEnum(prop)) {
     const enumName = pascalCase(`${objectName}_${propertyName}`);
@@ -443,6 +520,9 @@ function dartPropertyTypeFromSchema(objectName, propertyName, schema, opts) {
   return [finalType, subTypes.length ? subTypes : void 0];
 }
 function dartParsedJsonField(fieldName, jsonKey, dartType) {
+  if (dartType === "dynamic") {
+    return `${fieldName}: json["${jsonKey}"]`;
+  }
   if (isDartTypeWithNullables(dartType)) {
     switch (dartType) {
       case "String":
@@ -679,4 +759,4 @@ function isDartTypeWithNullables(input) {
   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 };
+export { isJsonSchemaNullType as a, isJsonSchemaObject as b, isJsonSchemaRecord as c, defineClientGeneratorPlugin as d, isJsonSchemaEnum as e, isJsonSchemaArray as f, dartClientGenerator as g, createDartClient as h, isJsonSchemaScalarType as i, dartServiceFromServiceDefinition as j, dartProcedureFromServiceDefinition as k, dartModelFromJsonSchema as l, dartPropertyTypeFromSchema as m, dartParsedJsonField as n, classTransformer as o, classListTransformer as p, isDartType as q, isDartTypeWithNullables as r, transformers as t };

package/dist/shared/arri.ebf86912.mjs

@@ -0,0 +1,179 @@
+const NUMBER_CHAR_RE = /\d/;
+const STR_SPLITTERS = ["-", "_", "/", "."];
+function isUppercase(char = "") {
+  if (NUMBER_CHAR_RE.test(char)) {
+    return void 0;
+  }
+  return char.toUpperCase() === char;
+}
+function splitByCase(string_, separators) {
+  const splitters = separators ?? STR_SPLITTERS;
+  const parts = [];
+  if (!string_ || typeof string_ !== "string") {
+    return parts;
+  }
+  let buff = "";
+  let previousUpper;
+  let previousSplitter;
+  for (const char of string_) {
+    const isSplitter = splitters.includes(char);
+    if (isSplitter === true) {
+      parts.push(buff);
+      buff = "";
+      previousUpper = void 0;
+      continue;
+    }
+    const isUpper = isUppercase(char);
+    if (previousSplitter === false) {
+      if (previousUpper === false && isUpper === true) {
+        parts.push(buff);
+        buff = char;
+        previousUpper = isUpper;
+        continue;
+      }
+      if (previousUpper === true && isUpper === false && buff.length > 1) {
+        const lastChar = buff[buff.length - 1];
+        parts.push(buff.slice(0, Math.max(0, buff.length - 1)));
+        buff = lastChar + char;
+        previousUpper = isUpper;
+        continue;
+      }
+    }
+    buff += char;
+    previousUpper = isUpper;
+    previousSplitter = isSplitter;
+  }
+  parts.push(buff);
+  return parts;
+}
+function upperFirst(string_) {
+  return !string_ ? "" : string_[0].toUpperCase() + string_.slice(1);
+}
+function lowerFirst(string_) {
+  return !string_ ? "" : string_[0].toLowerCase() + string_.slice(1);
+}
+function pascalCase(string_) {
+  return !string_ ? "" : (Array.isArray(string_) ? string_ : splitByCase(string_)).map((p) => upperFirst(p)).join("");
+}
+function camelCase(string_) {
+  return lowerFirst(pascalCase(string_));
+}
+function kebabCase(string_, joiner) {
+  return !string_ ? "" : (Array.isArray(string_) ? string_ : splitByCase(string_)).map((p) => p.toLowerCase()).join(joiner ?? "-");
+}
+
+const HttpMethodValues = [
+  "get",
+  "post",
+  "put",
+  "patch",
+  "delete",
+  "head"
+];
+const isHttpMethod = (input) => {
+  if (typeof input !== "string") {
+    return false;
+  }
+  return HttpMethodValues.includes(input);
+};
+
+function normalizeWhitespace(input) {
+  if (input.includes("\n\n")) {
+    return normalizeWhitespace(input.split("\n\n").join("\n"));
+  }
+  const lines = [];
+  for (const line of input.split("\n")) {
+    lines.push(line.trim());
+  }
+  const result = lines.join("\n").trim();
+  if (result.includes("\n\n")) {
+    return normalizeWhitespace(result.split("\n\n").join("\n"));
+  }
+  return result;
+}
+function isProcedureDef(input) {
+  if (typeof input !== "object") {
+    return false;
+  }
+  const expectedKeys = ["path", "method"];
+  const existingKeys = Object.keys(input);
+  for (const key of expectedKeys) {
+    if (!existingKeys.includes(key)) {
+      return false;
+    }
+  }
+  return isHttpMethod(input.method) && typeof input.path === "string" && (typeof input.params === "string" || typeof input.params === "undefined") && (typeof input.response === "string" || typeof input.response === "undefined");
+}
+function isServiceDef(input) {
+  if (typeof input !== "object") {
+    return false;
+  }
+  for (const key of Object.keys(input)) {
+    if (typeof input[key] !== "object") {
+      return false;
+    }
+  }
+  return true;
+}
+function isApplicationDef(input) {
+  if (typeof input !== "object") {
+    return false;
+  }
+  if (!("procedures" in input) || typeof input.procedures !== "object") {
+    return false;
+  }
+  if (!("models" in input) || typeof input.models !== "object") {
+    return false;
+  }
+  if (!("errors" in input) || typeof input.errors !== "object") {
+    return false;
+  }
+  return true;
+}
+function unflattenObject(data) {
+  if (Object(data) !== data || Array.isArray(data))
+    return data;
+  const regex = /\.?([^.[\]]+)|\[(\d+)\]/g;
+  const result = {};
+  for (const p in data) {
+    let cur = result;
+    let prop = "";
+    let m;
+    while (m = regex.exec(p)) {
+      cur = cur[prop] || (cur[prop] = m[2] ? [] : {});
+      prop = m[2] || m[1];
+    }
+    cur[prop] = data[p];
+  }
+  return result[""] || result;
+}
+function unflattenProcedures(procedures) {
+  return unflattenObject(procedures);
+}
+function setNestedObjectProperty(targetProp, value, object) {
+  const parts = targetProp.split(".");
+  let current = object;
+  for (let i = 0; i < parts.length; i++) {
+    const key = parts[i];
+    if (i === parts.length - 1) {
+      current[key] = value;
+    } else {
+      if (!current[key]) {
+        current[key] = {};
+      }
+      current = current[key];
+    }
+  }
+  return object;
+}
+const removeDisallowedChars = (input, disallowedChars) => {
+  let result = input;
+  for (const char of disallowedChars) {
+    if (result.includes(char)) {
+      result = result.split(char).join("");
+    }
+  }
+  return result;
+};
+
+export { isProcedureDef as a, unflattenProcedures as b, camelCase as c, isApplicationDef as d, isHttpMethod as e, isServiceDef as i, kebabCase as k, normalizeWhitespace as n, pascalCase as p, removeDisallowedChars as r, setNestedObjectProperty as s, unflattenObject as u };

package/package.json

@@ -18,14 +18,14 @@
     "scule": "^1.0.0",
     "globby": "^13.2.2",
     "pathe": "^1.1.1",
-    "citty": "^0.1.3",
+    "citty": "^0.1.4",
     "c12": "^1.4.2",
     "consola": "^3.2.3",
     "ofetch": "^1.3.3",
     "chokidar": "^3.5.3",
-    "listhen": "^1.4.8"
+    "listhen": "^1.5.0"
   },
-  "version": "0.0.38",
+  "version": "0.0.42",
   "repository": {
     "url": "https://github.com/modiimedia/arri"
   }