atmx-cli 0.137.0 → 0.138.0

package/dist/generators/model-generator.js

@@ -19,20 +19,44 @@ function generateModels(multiIr) {
             : Object.values(ir.models || {});
         enumsList.forEach((en) => sections.push(generateEnum(en)));
         modelsList.forEach((model) => sections.push(generateInterface(model, camelNs)));
+        sections.push(generateDomainProjectionTypes(ir.domain, modelsList));
         sections.push(`}\n`);
     }
     sections.push(generateMappers(multiIr));
     return sections.join("\n");
 }
+function generateDomainProjectionTypes(domain, models) {
+    if (!domain?.projections || !domain?.entities)
+        return "";
+    const entities = domain.entities || {};
+    const projections = domain.projections || {};
+    const availableModels = new Set(models.map((model) => String(model?.name || "")));
+    const lines = ["  export namespace Domain {"];
+    let count = 0;
+    for (const [name, projection] of Object.entries(projections)) {
+        const entity = entities[projection.entity];
+        const model = entity?.model;
+        const fields = Array.isArray(projection.fields) ? projection.fields : [];
+        if (!model || !availableModels.has(model) || fields.length === 0)
+            continue;
+        const fieldUnion = fields.map((field) => JSON.stringify((0, utils_1.camelCase)(field))).join(" | ");
+        lines.push(`    export type ${(0, utils_1.pascalCase)(name)} = Pick<${(0, utils_1.pascalCase)(model)}, ${fieldUnion}>;`);
+        count += 1;
+    }
+    lines.push("  }");
+    return count ? lines.join("\n") : "";
+}
 function generateEnum(en) {
     const name = (0, utils_1.pascalCase)(en.name);
     const values = en.values.map((v) => `  ${(0, utils_1.pascalCase)(v)}: "${v}"`).join(",\n");
-    return `
-  export const ${name} = {
-  ${values}
-  } as const;
-  export type ${name} = typeof ${name}[keyof typeof ${name}];
-  `;
+    return [
+        "",
+        `  export const ${name} = {`,
+        values,
+        "  } as const;",
+        `  export type ${name} = typeof ${name}[keyof typeof ${name}];`,
+        "",
+    ].join("\n");
 }
 function generateInterface(model, ns) {
     const name = (0, utils_1.pascalCase)(model.name);
@@ -42,11 +66,7 @@ function generateInterface(model, ns) {
         return `    ${(0, utils_1.camelCase)(f.name)}${f.isOptional ? "?" : ""}: ${type};`;
     })
         .join("\n");
-    return `
-  export interface ${name} {
-${fields}
-  }
-  `;
+    return ["", `  export interface ${name} {`, fields, "  }", ""].join("\n");
 }
 function generateMappers(multiIr) {
     const lines = [`export const Mappers: Record<string, any> = {`];

package/dist/generators/sdk-generator.js

@@ -16,7 +16,9 @@ function moduleIdentifier(namespace) {
     return `${namespaceIdentifier(namespace)}Module`;
 }
 // Helper to convert Axiom TypeRef to TypeScript Types
-function getTsType(namespace, typeRef) {
+function getTsType(namespace, typeRef, projection) {
+    if (projection)
+        return `models.${namespaceIdentifier(namespace)}.Domain.${(0, utils_js_1.pascalCase)(projection)}`;
     if (!typeRef)
         return "any";
     if (typeRef.kind === "named") {
@@ -128,8 +130,10 @@ function generateSDKContent(contracts, isReact) {
             const fnName = endpoint.name.replace(/_([a-z])/g, (g) => g[1].toUpperCase());
             const capFnName = fnName.charAt(0).toUpperCase() + fnName.slice(1);
             if (isReact) {
-                const tsType = getTsType(namespace, endpoint.returnType);
-                const decoder = getDecoder(namespace, endpoint.returnType);
+                const tsType = getTsType(namespace, endpoint.returnType, endpoint.responseProjection);
+                const decoder = endpoint.responseProjection
+                    ? `(json: any) => json as ${tsType}`
+                    : getDecoder(namespace, endpoint.returnType);
                 content += `  get${capFnName}Def(\n`;
                 content += `    args?: Record<string, any>,\n`;
                 content += `  ): AxiomQueryDef<${tsType}> {\n`;

package/dist/generators/utils.js

@@ -26,22 +26,22 @@ function normalizeIr(obj) {
             const camelKey = key.replace(/_([a-z])/g, (g) => g[1].toUpperCase());
             newObj[camelKey] = normalizeIr(obj[key]);
         }
-        if (newObj.endpoints &&
-            typeof newObj.endpoints === "object" &&
-            !Array.isArray(newObj.endpoints)) {
+        // Only the IR root owns endpoint/model/enum maps. A previous generic
+        // conversion treated *any* field named `endpoints` as an IR map, which
+        // corrupted valid model fields such as AgentSemanticView.endpoints into an
+        // array of field-property values. Keep the structural normalization tied
+        // to the actual IR shape.
+        const isIrRoot = typeof newObj.serviceName === "string";
+        if (isIrRoot && 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)) {
+        if (isIrRoot && 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)) {
+        if (isIrRoot && newObj.enums && typeof newObj.enums === "object" && !Array.isArray(newObj.enums)) {
             newObj.enums = Object.values(newObj.enums);
         }
-        if (Array.isArray(newObj.models)) {
+        if (isIrRoot && Array.isArray(newObj.models)) {
             newObj.models = newObj.models.map((model) => {
                 if (model.fields &&
                     typeof model.fields === "object" &&

package/dist/index.js

@@ -81,6 +81,9 @@ program
         if (!rawFile.ir)
             continue;
         multiIr[namespace] = (0, utils_1.normalizeIr)(rawFile.ir);
+        // Domain Model v1 is carried inside `ir` and drives generated projection
+        // types. The immutable artifact remains the source of truth; the TOML
+        // file continues to contain only dependency and verification metadata.
         // ✨ NEW: Combine IR with TOML config for the SDK generator
         generatorPayload[namespace] = {
             ir: multiIr[namespace],

package/package.json

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

package/src/generators/model-generator.ts

@@ -1,5 +1,5 @@
 // FILE: atmx-cli/src/generators/model-generator.ts
-import { AxiomEnum, AxiomModel, MultiIR } from "../types";
+import { AxiomDomainModel, AxiomEnum, AxiomModel, MultiIR } from "../types";
 import { pascalCase, camelCase, mapTypeToTs } from "./utils";
 
 export function generateModels(multiIr: MultiIR): string {
@@ -24,6 +24,7 @@ export function generateModels(multiIr: MultiIR): string {
     modelsList.forEach((model: any) =>
       sections.push(generateInterface(model, camelNs)),
     );
+    sections.push(generateDomainProjectionTypes(ir.domain, modelsList));
 
     sections.push(`}\n`);
   }
@@ -32,15 +33,37 @@ export function generateModels(multiIr: MultiIR): string {
   return sections.join("\n");
 }
 
+function generateDomainProjectionTypes(domain: AxiomDomainModel | undefined, models: any[]): string {
+  if (!domain?.projections || !domain?.entities) return "";
+  const entities = domain.entities || {};
+  const projections = domain.projections || {};
+  const availableModels = new Set(models.map((model) => String(model?.name || "")));
+  const lines = ["  export namespace Domain {"];
+  let count = 0;
+  for (const [name, projection] of Object.entries(projections)) {
+    const entity = entities[(projection as any).entity];
+    const model = entity?.model;
+    const fields = Array.isArray((projection as any).fields) ? (projection as any).fields : [];
+    if (!model || !availableModels.has(model) || fields.length === 0) continue;
+    const fieldUnion = fields.map((field: string) => JSON.stringify(camelCase(field))).join(" | ");
+    lines.push(`    export type ${pascalCase(name)} = Pick<${pascalCase(model)}, ${fieldUnion}>;`);
+    count += 1;
+  }
+  lines.push("  }");
+  return count ? lines.join("\n") : "";
+}
+
 function generateEnum(en: AxiomEnum): string {
   const name = pascalCase(en.name);
   const values = en.values.map((v) => `  ${pascalCase(v)}: "${v}"`).join(",\n");
-  return `
-  export const ${name} = {
-  ${values}
-  } as const;
-  export type ${name} = typeof ${name}[keyof typeof ${name}];
-  `;
+  return [
+    "",
+    `  export const ${name} = {`,
+    values,
+    "  } as const;",
+    `  export type ${name} = typeof ${name}[keyof typeof ${name}];`,
+    "",
+  ].join("\n");
 }
 
 function generateInterface(model: AxiomModel, ns: string): string {
@@ -52,11 +75,7 @@ function generateInterface(model: AxiomModel, ns: string): string {
     })
     .join("\n");
 
-  return `
-  export interface ${name} {
-${fields}
-  }
-  `;
+  return ["", `  export interface ${name} {`, fields, "  }", ""].join("\n");
 }
 
 function generateMappers(multiIr: MultiIR): string {

package/src/generators/sdk-generator.ts

@@ -1,5 +1,5 @@
 import { AxiomIR, AxiomEndpoint, AxiomTypeRef } from "../types.js";
-import { camelCase } from "./utils.js";
+import { camelCase, pascalCase } from "./utils.js";
 
 export interface ContractPayload {
   ir: AxiomIR;
@@ -24,7 +24,8 @@ function moduleIdentifier(namespace: string): string {
 }
 
 // Helper to convert Axiom TypeRef to TypeScript Types
-function getTsType(namespace: string, typeRef?: AxiomTypeRef): string {
+function getTsType(namespace: string, typeRef?: AxiomTypeRef, projection?: string): string {
+  if (projection) return `models.${namespaceIdentifier(namespace)}.Domain.${pascalCase(projection)}`;
   if (!typeRef) return "any";
   if (typeRef.kind === "named") {
     return `models.${namespaceIdentifier(namespace)}.${typeRef.value}`;
@@ -139,8 +140,10 @@ export function generateSDKContent(
       const capFnName = fnName.charAt(0).toUpperCase() + fnName.slice(1);
 
       if (isReact) {
-        const tsType = getTsType(namespace, endpoint.returnType);
-        const decoder = getDecoder(namespace, endpoint.returnType);
+        const tsType = getTsType(namespace, endpoint.returnType, endpoint.responseProjection);
+        const decoder = endpoint.responseProjection
+          ? `(json: any) => json as ${tsType}`
+          : getDecoder(namespace, endpoint.returnType);
 
         content += `  get${capFnName}Def(\n`;
         content += `    args?: Record<string, any>,\n`;

package/src/generators/utils.ts

@@ -20,28 +20,22 @@ export function normalizeIr(obj: any): any {
       const camelKey = key.replace(/_([a-z])/g, (g) => g[1].toUpperCase());
       newObj[camelKey] = normalizeIr(obj[key]);
     }
-    if (
-      newObj.endpoints &&
-      typeof newObj.endpoints === "object" &&
-      !Array.isArray(newObj.endpoints)
-    ) {
+    // Only the IR root owns endpoint/model/enum maps. A previous generic
+    // conversion treated *any* field named `endpoints` as an IR map, which
+    // corrupted valid model fields such as AgentSemanticView.endpoints into an
+    // array of field-property values. Keep the structural normalization tied
+    // to the actual IR shape.
+    const isIrRoot = typeof newObj.serviceName === "string";
+    if (isIrRoot && 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)
-    ) {
+    if (isIrRoot && 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)
-    ) {
+    if (isIrRoot && newObj.enums && typeof newObj.enums === "object" && !Array.isArray(newObj.enums)) {
       newObj.enums = Object.values(newObj.enums);
     }
-    if (Array.isArray(newObj.models)) {
+    if (isIrRoot && Array.isArray(newObj.models)) {
       newObj.models = newObj.models.map((model: any) => {
         if (
           model.fields &&

package/src/index.ts

@@ -66,6 +66,10 @@ program
 
       multiIr[namespace] = normalizeIr(rawFile.ir);
 
+      // Domain Model v1 is carried inside `ir` and drives generated projection
+      // types. The immutable artifact remains the source of truth; the TOML
+      // file continues to contain only dependency and verification metadata.
+
       // ✨ NEW: Combine IR with TOML config for the SDK generator
       generatorPayload[namespace] = {
         ir: multiIr[namespace],

package/src/types.ts

@@ -3,6 +3,7 @@ export interface AxiomIR {
   endpoints: AxiomEndpoint[];
   models: Record<string, AxiomModel>;
   enums: Record<string, AxiomEnum>;
+  domain?: AxiomDomainModel;
 }
 
 export interface AxiomEndpoint {
@@ -14,6 +15,8 @@ export interface AxiomEndpoint {
   returnType: AxiomTypeRef;
   returnIsOptional: boolean;
   isStream: boolean;
+  requestProjection?: string;
+  responseProjection?: string;
 }
 
 export interface AxiomParameter {
@@ -45,6 +48,24 @@ export interface AxiomEnum {
   values: string[];
 }
 
+export interface AxiomDomainModel {
+  entities: Record<string, AxiomDomainEntity>;
+  projections: Record<string, AxiomDomainProjection>;
+}
+
+export interface AxiomDomainEntity {
+  id?: string;
+  model: string;
+  key: string[];
+}
+
+export interface AxiomDomainProjection {
+  id?: string;
+  entity: string;
+  fields: string[];
+  audience: string;
+}
+
 export interface AtmxContractConfig {
   file: string; // Path relative to the config file (e.g., "./auth.axiom")
   baseUrl: string; // The URL for runtime (not used during code generation, but part of schema)