atmx-cli 0.32.0 → 0.34.0

package/dist/generators/sdk-generator.js

@@ -5,16 +5,18 @@ const utils_1 = require("./utils");
 function generateSdk(multiIr) {
     const lines = [
         `// GENERATED CODE – DO NOT EDIT.`,
-        `import { useAxiomQuery, useAxiomMutation } from 'atmx-react';`,
-        `import type { AxiomQueryDef } from 'atmx-react';`,
         `import * as models from './models';\n`,
     ];
     for (const [ns, ir] of Object.entries(multiIr)) {
         const pascalNs = (0, utils_1.pascalCase)(ns);
         lines.push(`export class ${pascalNs}Module {`);
-        const endpoints = ir.endpoints || [];
+        // Support both old array format and new object map format
+        const endpointsMap = ir.endpoints || {};
+        const endpoints = Array.isArray(endpointsMap)
+            ? endpointsMap
+            : Object.values(endpointsMap);
         endpoints.forEach((ep) => {
-            lines.push(generateEndpointHook(ep, ns, pascalNs));
+            lines.push(generateEndpointMethod(ep, ns, pascalNs));
         });
         lines.push(`}\n`);
     }
@@ -25,68 +27,30 @@ function generateSdk(multiIr) {
     lines.push(`}\nexport const sdk = new AxiomSdk();`);
     return lines.join("\n");
 }
-function generateEndpointHook(ep, ns, pascalNs) {
-    const isQuery = ep.method ? ep.method.toUpperCase() === "GET" : true;
-    const rawReturnType = (0, utils_1.mapTypeToTs)(ep.returnType, pascalNs);
-    const returnType = rawReturnType === "void" || rawReturnType === "any"
-        ? rawReturnType
-        : prefixModels(rawReturnType);
+function generateEndpointMethod(ep, ns, pascalNs) {
     const params = ep.parameters || [];
     const argType = params.length > 0
         ? `{ ${params.map((p) => `${(0, utils_1.camelCase)(p.name)}${p.isOptional ? "?" : ""}: ${prefixModels((0, utils_1.mapTypeToTs)(p.typeRef, pascalNs))}`).join(", ")} }`
         : "void";
-    const factoryLogic = generateQueryDefFactory(ep, returnType, ns);
-    // NEW: Every endpoint now generates BOTH a raw definition getter and a hook!
+    // We generate a method that takes the typed arguments and returns the exact string ATMX expects
     return `
-  /** Raw definition for <AxQuery> or <AxMutate> */
-  get${(0, utils_1.pascalCase)(ep.name)}Def(args: ${argType}): AxiomQueryDef<${returnType}> {
-    return (${factoryLogic})(args);
-  }
-
-  /** Reactive hook for functional components */
-  use${(0, utils_1.pascalCase)(ep.name)}${!isQuery ? "Mutation" : ""}(${isQuery ? `args: ${argType}, options?: { enabled?: boolean }` : ""}) {
-    const factory = ${factoryLogic};
-    return ${isQuery ? `useAxiomQuery<${returnType}>(factory(args), options)` : `useAxiomMutation<${returnType}, ${argType}>(factory)`};
+  /** RPC String Generator for <AxQuery> or <AxMutate> */
+  ${(0, utils_1.camelCase)(ep.name)}(args${params.length > 0 ? "" : "?"}: ${argType}): string {
+    const argsStr = args && Object.keys(args).length > 0 ? JSON.stringify(args) : '';
+    return \`${ns}.${ep.name}(\${argsStr})\`;
   }\n`;
 }
-function generateQueryDefFactory(ep, returnType, ns) {
-    const params = ep.parameters || [];
-    const bodyParam = params.find((p) => p.source === "body");
-    const payloadLogic = bodyParam
-        ? `const payload = (args as any).${(0, utils_1.camelCase)(bodyParam.name)};`
-        : `const payload = undefined;`;
-    const decLogic = generateLambda(ep.returnType, "fromJson", ns);
-    const serLogic = bodyParam
-        ? generateLambda(bodyParam.typeRef, "toJson", ns)
-        : `(p: any) => p`;
-    // THIN DEFINITION: Leaves URL logic up to ATMX Core Router
-    return `(args: any): AxiomQueryDef<${returnType}> => {
-      ${payloadLogic}
-      return {
-        namespace: "${ns}",
-        name: "${ep.name}",
-        endpointId: ${ep.id},
-        method: "${ep.method ? ep.method.toUpperCase() : "GET"}",
-        path: "${ep.path}",
-        payload: payload,
-        args: args as any,
-        decoder: ${decLogic},
-        serializer: ${serLogic},
-        isStream: ${ep.isStream === true}
-      };
-    }`;
-}
-function generateLambda(typeRef, mode, ns) {
-    if (!typeRef || !typeRef.kind || typeRef.kind === "void")
-        return mode === "fromJson" ? `() => undefined` : `(p: any) => p`;
-    if (typeRef.kind === "list" && typeRef.value?.kind === "named")
-        return `(data: any[]) => data.map(models.Mappers.${(0, utils_1.camelCase)(ns)}.${(0, utils_1.pascalCase)(typeRef.value.value)}.${mode})`;
-    if (typeRef.kind === "named")
-        return `models.Mappers.${(0, utils_1.camelCase)(ns)}.${(0, utils_1.pascalCase)(typeRef.value)}.${mode}`;
-    return `(data: any) => data`;
-}
 function prefixModels(type) {
-    if (!type || type === "void" || type === "any")
+    const primitives = [
+        "string",
+        "number",
+        "boolean",
+        "Date",
+        "Uint8Array",
+        "void",
+        "any",
+    ];
+    if (!type || primitives.includes(type))
         return type;
     if (type.endsWith("[]"))
         return `${prefixModels(type.slice(0, -2))}[]`;

package/dist/generators/utils.js

@@ -7,27 +7,55 @@ exports.normalizeIr = normalizeIr;
 exports.mapTypeToTs = mapTypeToTs;
 function pascalCase(str) {
     if (!str)
-        return '';
+        return "";
     return str
         .split(/[_\-\s]+/)
-        .map(part => part.charAt(0).toUpperCase() + part.slice(1))
-        .join('');
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join("");
 }
 function camelCase(str) {
     const pascal = pascalCase(str);
     return pascal.charAt(0).toLowerCase() + pascal.slice(1);
 }
 function normalizeIr(obj) {
-    if (Array.isArray(obj))
-        return obj.map(normalizeIr);
-    if (obj !== null && typeof obj === 'object') {
+    // ✨ FIX: Recursively convert Axiom Core HashMaps back into Arrays for the generator
+    if (obj !== null && typeof obj === "object") {
         const newObj = {};
         for (const key of Object.keys(obj)) {
             const camelKey = key.replace(/_([a-z])/g, (g) => g[1].toUpperCase());
             newObj[camelKey] = normalizeIr(obj[key]);
         }
+        // Convert common Maps to Arrays if they exist
+        if (newObj.endpoints &&
+            typeof newObj.endpoints === "object" &&
+            !Array.isArray(newObj.endpoints)) {
+            newObj.endpoints = Object.values(newObj.endpoints);
+        }
+        if (newObj.models &&
+            typeof newObj.models === "object" &&
+            !Array.isArray(newObj.models)) {
+            newObj.models = Object.values(newObj.models);
+        }
+        if (newObj.enums &&
+            typeof newObj.enums === "object" &&
+            !Array.isArray(newObj.enums)) {
+            newObj.enums = Object.values(newObj.enums);
+        }
+        // Traverse down into models to normalize fields
+        if (Array.isArray(newObj.models)) {
+            newObj.models = newObj.models.map((model) => {
+                if (model.fields &&
+                    typeof model.fields === "object" &&
+                    !Array.isArray(model.fields)) {
+                    model.fields = Object.values(model.fields);
+                }
+                return model;
+            });
+        }
         return newObj;
     }
+    if (Array.isArray(obj))
+        return obj.map(normalizeIr);
     return obj;
 }
 /**
@@ -35,25 +63,31 @@ function normalizeIr(obj) {
  */
 function mapTypeToTs(typeRef, ns) {
     if (!typeRef)
-        return 'any';
-    if (typeRef.kind === 'primitive') {
+        return "any";
+    if (typeRef.kind === "primitive") {
         switch (typeRef.value) {
-            case 'string': return 'string';
-            case 'int':
-            case 'float':
-            case 'double': return 'number';
-            case 'boolean': return 'boolean';
-            case 'dateTime': return 'Date';
-            case 'bytes': return 'Uint8Array';
-            default: return 'any';
+            case "string":
+                return "string";
+            case "int":
+            case "float":
+            case "double":
+                return "number";
+            case "boolean":
+                return "boolean";
+            case "dateTime":
+                return "Date";
+            case "bytes":
+                return "Uint8Array";
+            default:
+                return "any";
         }
     }
-    if (typeRef.kind === 'named') {
+    if (typeRef.kind === "named") {
         const name = pascalCase(typeRef.value);
-        return ns ? `${ns}${name}` : name; // ✅ FIX HERE
+        return ns ? `${ns}${name}` : name;
     }
-    if (typeRef.kind === 'list') {
+    if (typeRef.kind === "list") {
         return `${mapTypeToTs(typeRef.value, ns)}[]`;
     }
-    return 'any';
+    return "any";
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atmx-cli",
-  "version": "0.32.0",
+  "version": "0.34.0",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

package/src/generators/sdk-generator.ts

@@ -5,17 +5,21 @@ import { pascalCase, camelCase, mapTypeToTs } from "./utils";
 export function generateSdk(multiIr: MultiIR): string {
   const lines: string[] = [
     `// GENERATED CODE – DO NOT EDIT.`,
-    `import { useAxiomQuery, useAxiomMutation } from 'atmx-react';`,
-    `import type { AxiomQueryDef } from 'atmx-react';`,
     `import * as models from './models';\n`,
   ];
 
   for (const [ns, ir] of Object.entries(multiIr)) {
     const pascalNs = pascalCase(ns);
     lines.push(`export class ${pascalNs}Module {`);
-    const endpoints = ir.endpoints || [];
+
+    // Support both old array format and new object map format
+    const endpointsMap = ir.endpoints || {};
+    const endpoints = Array.isArray(endpointsMap)
+      ? endpointsMap
+      : Object.values(endpointsMap);
+
     endpoints.forEach((ep: any) => {
-      lines.push(generateEndpointHook(ep, ns, pascalNs));
+      lines.push(generateEndpointMethod(ep, ns, pascalNs));
     });
     lines.push(`}\n`);
   }
@@ -31,89 +35,38 @@ export function generateSdk(multiIr: MultiIR): string {
   return lines.join("\n");
 }
 
-function generateEndpointHook(
+function generateEndpointMethod(
   ep: AxiomEndpoint,
   ns: string,
   pascalNs: string,
 ): string {
-  const isQuery = ep.method ? ep.method.toUpperCase() === "GET" : true;
-  const rawReturnType = mapTypeToTs(ep.returnType, pascalNs);
-  const returnType =
-    rawReturnType === "void" || rawReturnType === "any"
-      ? rawReturnType
-      : prefixModels(rawReturnType);
-
   const params = ep.parameters || [];
+
   const argType =
     params.length > 0
       ? `{ ${params.map((p) => `${camelCase(p.name)}${p.isOptional ? "?" : ""}: ${prefixModels(mapTypeToTs(p.typeRef, pascalNs))}`).join(", ")} }`
       : "void";
 
-  const factoryLogic = generateQueryDefFactory(ep, returnType, ns);
-
-  // NEW: Every endpoint now generates BOTH a raw definition getter and a hook!
+  // We generate a method that takes the typed arguments and returns the exact string ATMX expects
   return `
-  /** Raw definition for <AxQuery> or <AxMutate> */
-  get${pascalCase(ep.name)}Def(args: ${argType}): AxiomQueryDef<${returnType}> {
-    return (${factoryLogic})(args);
-  }
-
-  /** Reactive hook for functional components */
-  use${pascalCase(ep.name)}${!isQuery ? "Mutation" : ""}(${isQuery ? `args: ${argType}, options?: { enabled?: boolean }` : ""}) {
-    const factory = ${factoryLogic};
-    return ${isQuery ? `useAxiomQuery<${returnType}>(factory(args), options)` : `useAxiomMutation<${returnType}, ${argType}>(factory)`};
+  /** RPC String Generator for <AxQuery> or <AxMutate> */
+  ${camelCase(ep.name)}(args${params.length > 0 ? "" : "?"}: ${argType}): string {
+    const argsStr = args && Object.keys(args).length > 0 ? JSON.stringify(args) : '';
+    return \`${ns}.${ep.name}(\${argsStr})\`;
   }\n`;
 }
 
-function generateQueryDefFactory(
-  ep: AxiomEndpoint,
-  returnType: string,
-  ns: string,
-): string {
-  const params = ep.parameters || [];
-  const bodyParam = params.find((p) => p.source === "body");
-  const payloadLogic = bodyParam
-    ? `const payload = (args as any).${camelCase(bodyParam.name)};`
-    : `const payload = undefined;`;
-  const decLogic = generateLambda(ep.returnType, "fromJson", ns);
-  const serLogic = bodyParam
-    ? generateLambda(bodyParam.typeRef, "toJson", ns)
-    : `(p: any) => p`;
-
-  // THIN DEFINITION: Leaves URL logic up to ATMX Core Router
-  return `(args: any): AxiomQueryDef<${returnType}> => {
-      ${payloadLogic}
-      return {
-        namespace: "${ns}",
-        name: "${ep.name}",
-        endpointId: ${ep.id},
-        method: "${ep.method ? ep.method.toUpperCase() : "GET"}",
-        path: "${ep.path}",
-        payload: payload,
-        args: args as any,
-        decoder: ${decLogic},
-        serializer: ${serLogic},
-        isStream: ${ep.isStream === true}
-      };
-    }`;
-}
-
-function generateLambda(
-  typeRef: any,
-  mode: "fromJson" | "toJson",
-  ns: string,
-): string {
-  if (!typeRef || !typeRef.kind || typeRef.kind === "void")
-    return mode === "fromJson" ? `() => undefined` : `(p: any) => p`;
-  if (typeRef.kind === "list" && typeRef.value?.kind === "named")
-    return `(data: any[]) => data.map(models.Mappers.${camelCase(ns)}.${pascalCase(typeRef.value.value)}.${mode})`;
-  if (typeRef.kind === "named")
-    return `models.Mappers.${camelCase(ns)}.${pascalCase(typeRef.value)}.${mode}`;
-  return `(data: any) => data`;
-}
-
 function prefixModels(type: string): string {
-  if (!type || type === "void" || type === "any") return type;
+  const primitives = [
+    "string",
+    "number",
+    "boolean",
+    "Date",
+    "Uint8Array",
+    "void",
+    "any",
+  ];
+  if (!type || primitives.includes(type)) return type;
   if (type.endsWith("[]")) return `${prefixModels(type.slice(0, -2))}[]`;
   if (type.startsWith("models.")) return type;
   return `models.${type}`;

package/src/generators/utils.ts

@@ -1,58 +1,104 @@
 // atmx-cli/src/generators/utils.ts
 
 export function pascalCase(str: string): string {
-    if (!str) return '';
-    return str
-        .split(/[_\-\s]+/)
-        .map(part => part.charAt(0).toUpperCase() + part.slice(1))
-        .join('');
+  if (!str) return "";
+  return str
+    .split(/[_\-\s]+/)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join("");
 }
 
 export function camelCase(str: string): string {
-    const pascal = pascalCase(str);
-    return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+  const pascal = pascalCase(str);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
 }
 
 export function normalizeIr(obj: any): any {
-    if (Array.isArray(obj)) return obj.map(normalizeIr);
-    if (obj !== null && typeof obj === 'object') {
-        const newObj: any = {};
-        for (const key of Object.keys(obj)) {
-            const camelKey = key.replace(/_([a-z])/g, (g) => g[1].toUpperCase());
-            newObj[camelKey] = normalizeIr(obj[key]);
+  // ✨ FIX: Recursively convert Axiom Core HashMaps back into Arrays for the generator
+  if (obj !== null && typeof obj === "object") {
+    const newObj: any = {};
+    for (const key of Object.keys(obj)) {
+      const camelKey = key.replace(/_([a-z])/g, (g) => g[1].toUpperCase());
+      newObj[camelKey] = normalizeIr(obj[key]);
+    }
+
+    // Convert common Maps to Arrays if they exist
+    if (
+      newObj.endpoints &&
+      typeof newObj.endpoints === "object" &&
+      !Array.isArray(newObj.endpoints)
+    ) {
+      newObj.endpoints = Object.values(newObj.endpoints);
+    }
+    if (
+      newObj.models &&
+      typeof newObj.models === "object" &&
+      !Array.isArray(newObj.models)
+    ) {
+      newObj.models = Object.values(newObj.models);
+    }
+    if (
+      newObj.enums &&
+      typeof newObj.enums === "object" &&
+      !Array.isArray(newObj.enums)
+    ) {
+      newObj.enums = Object.values(newObj.enums);
+    }
+
+    // Traverse down into models to normalize fields
+    if (Array.isArray(newObj.models)) {
+      newObj.models = newObj.models.map((model: any) => {
+        if (
+          model.fields &&
+          typeof model.fields === "object" &&
+          !Array.isArray(model.fields)
+        ) {
+          model.fields = Object.values(model.fields);
         }
-        return newObj;
+        return model;
+      });
     }
-    return obj;
+
+    return newObj;
+  }
+
+  if (Array.isArray(obj)) return obj.map(normalizeIr);
+  return obj;
 }
 
 /**
  * @param scopedNamespace If provided (e.g. 'Auth'), prefixes named types with 'models.Auth.'
  */
 export function mapTypeToTs(typeRef: any, ns?: string): string {
-    if (!typeRef) return 'any';
-
-    if (typeRef.kind === 'primitive') {
-        switch (typeRef.value) {
-            case 'string': return 'string';
-            case 'int':
-            case 'float':
-            case 'double': return 'number';
-            case 'boolean': return 'boolean';
-            case 'dateTime': return 'Date';
-            case 'bytes': return 'Uint8Array';
-            default: return 'any';
-        }
-    }
+  if (!typeRef) return "any";
 
-    if (typeRef.kind === 'named') {
-        const name = pascalCase(typeRef.value);
-        return ns ? `${ns}${name}` : name; // ✅ FIX HERE
+  if (typeRef.kind === "primitive") {
+    switch (typeRef.value) {
+      case "string":
+        return "string";
+      case "int":
+      case "float":
+      case "double":
+        return "number";
+      case "boolean":
+        return "boolean";
+      case "dateTime":
+        return "Date";
+      case "bytes":
+        return "Uint8Array";
+      default:
+        return "any";
     }
+  }
 
-    if (typeRef.kind === 'list') {
-        return `${mapTypeToTs(typeRef.value, ns)}[]`;
-    }
+  if (typeRef.kind === "named") {
+    const name = pascalCase(typeRef.value);
+    return ns ? `${ns}${name}` : name;
+  }
+
+  if (typeRef.kind === "list") {
+    return `${mapTypeToTs(typeRef.value, ns)}[]`;
+  }
 
-    return 'any';
-}
+  return "any";
+}