atmx-web 0.44.0 → 0.47.0

package/src/core/query.ts

@@ -1,162 +0,0 @@
-// FILE: src/core/query.ts
-import { wasmEngine, allocString, allocBytes } from "./wasm";
-import { pendingRequests } from "./callback";
-import { Route, buildRequestPath } from "./router";
-import { AtmxContextData } from "./context";
-import { EventType } from "./types";
-import { atmx } from "../index";
-
-let globalReqCounter = 0;
-type Listener = (state: Partial<AtmxContextData>) => void;
-
-export class ActiveQuery {
-  key: string;
-  route: Route;
-  args: Record<string, any>;
-  state: Partial<AtmxContextData>;
-  listeners: Set<Listener> = new Set();
-  currentReqId: number | null = null;
-
-  constructor(key: string, route: Route, args: Record<string, any>) {
-    this.key = key;
-    this.route = route;
-    this.args = args;
-    this.state = {
-      state: "idle",
-      isFetching: false,
-      source: null,
-      data: null,
-      error: null,
-    };
-  }
-
-  subscribe(listener: Listener) {
-    this.listeners.add(listener);
-    listener(this.state); // Instantly hydrate the DOM element with current state
-  }
-
-  update(newState: Partial<AtmxContextData>) {
-    this.state = { ...this.state, ...newState };
-    this.listeners.forEach((l) => l(this.state)); // Broadcast to all DOM elements!
-  }
-
-  fetch(force: boolean = false) {
-    if (this.state.isFetching && !force) return;
-
-    this.update({
-      state: this.state.data ? "data" : "loading",
-      isFetching: true,
-      error: null,
-    });
-
-    const reqId = ++globalReqCounter;
-    this.currentReqId = reqId;
-
-    const { path, remainingArgs } = buildRequestPath(this.route, this.args);
-
-    let payloadBytes = new Uint8Array(0);
-    if (Object.keys(remainingArgs).length > 0) {
-      payloadBytes = new TextEncoder().encode(JSON.stringify(remainingArgs));
-    }
-
-    if (atmx.debug) {
-      console.groupCollapsed(
-        `%c➔ WASM QUERY [#${reqId}]`,
-        `color: #7c3aed; font-weight: bold;`,
-      );
-      console.log("Namespace:", this.route.namespace);
-      console.log("Endpoint ID:", this.route.id);
-      console.log("Path:", path);
-      console.groupEnd();
-    }
-
-    pendingRequests.set(reqId, {
-      isStream: this.route.isStream,
-      onResponse: (res) => {
-        if (this.currentReqId !== reqId) return;
-
-        if (atmx.debug) {
-          const evtName =
-            res.eventType === 1
-              ? "NetworkSuccess"
-              : res.eventType === 2
-                ? "CacheHit"
-                : res.eventType === 3
-                  ? "CacheHitAndFetching"
-                  : res.eventType === 4
-                    ? "Error"
-                    : "Complete";
-          console.groupCollapsed(
-            `%c← WASM RESP [#${reqId}]`,
-            `color: #059669; font-weight: bold;`,
-          );
-          console.log("Event Type:", evtName);
-          if (res.data) console.log("Data:", res.data);
-          if (res.error) console.log("Error:", res.error);
-          console.groupEnd();
-        }
-
-        if (res.eventType === EventType.Error) {
-          this.update({ state: "error", error: res.error, isFetching: false });
-          return;
-        }
-
-        if (res.data) {
-          let source: "cache" | "network" = "network";
-          let isFetching = false;
-
-          if (res.eventType === EventType.CacheHit) {
-            source = "cache";
-            isFetching = false;
-          } else if (res.eventType === EventType.CacheHitAndFetching) {
-            source = "cache";
-            isFetching = true;
-          } else if (res.eventType === EventType.NetworkSuccess) {
-            source = "network";
-            isFetching = false;
-          }
-
-          this.update({ state: "data", data: res.data, source, isFetching });
-        }
-      },
-      onComplete: () => {
-        if (this.currentReqId !== reqId) return;
-        if (atmx.debug)
-          console.log(`%c✔ Stream Complete [#${reqId}]`, "color: #94a3b8;");
-        this.update({ isFetching: false });
-      },
-    });
-
-    const nsStr = allocString(this.route.namespace);
-    const mStr = allocString(this.route.method);
-    const pStr = allocString(path);
-    const payloadPtr = allocBytes(payloadBytes);
-    const tpStr = allocString(""); // Traceparent (empty for now)
-    const hStr = allocString(""); // Headers (empty for now)
-
-    wasmEngine.axiom_wasm_call(
-      reqId,
-      nsStr.ptr,
-      nsStr.len,
-      this.route.id,
-      mStr.ptr,
-      mStr.len,
-      pStr.ptr,
-      pStr.len,
-      tpStr.ptr,
-      tpStr.len,
-      hStr.ptr,
-      hStr.len,
-      payloadPtr,
-      payloadBytes.length,
-    );
-
-    wasmEngine.axiom_free_memory(nsStr.ptr, nsStr.len);
-    wasmEngine.axiom_free_memory(mStr.ptr, mStr.len);
-    wasmEngine.axiom_free_memory(pStr.ptr, pStr.len);
-    wasmEngine.axiom_free_memory(tpStr.ptr, tpStr.len);
-    wasmEngine.axiom_free_memory(hStr.ptr, hStr.len);
-  }
-}
-
-export const queryRegistry = new Map<string, ActiveQuery>();

package/src/core/router.ts

@@ -1,91 +0,0 @@
-// FILE: src/core/router.ts
-
-export interface RouteAuth {
-  required: boolean;
-  methods: any[];
-}
-
-export interface Route {
-  id: number;
-  namespace: string;
-  name: string;
-  method: string;
-  pathTemplate: string;
-  isStream: boolean;
-  auth?: RouteAuth | null;
-  bodyParam?: string | null; // <-- NEW
-}
-
-const routes = new Map<string, Route>();
-
-export function initRouter(namespace: string, contractJson: any) {
-  const endpoints = contractJson?.ir?.endpoints;
-  if (!endpoints) return;
-
-  const epList = Array.isArray(endpoints)
-    ? endpoints
-    : Object.values(endpoints);
-
-  epList.forEach((ep: any) => {
-    const routeKey = `${namespace}.${ep.name}`;
-
-    // ✨ Detect which param belongs in the body
-    const bodyParam =
-      ep.parameters?.find((p: any) => p.source === "body")?.name || null;
-
-    routes.set(routeKey, {
-      id: ep.id,
-      namespace: namespace,
-      name: ep.name,
-      method: ep.method ? ep.method.toUpperCase() : "GET",
-      pathTemplate: ep.path,
-      isStream: ep.isStream || false,
-      auth: ep.auth || null,
-      bodyParam: bodyParam, // <-- NEW
-    });
-  });
-  console.log(
-    `🛣️ ATMX Router: Mapped ${epList.length} endpoints for '${namespace}'.`,
-  );
-}
-
-export function resolveRoute(rpcCall: string): Route | null {
-  return routes.get(rpcCall.trim()) || null;
-}
-
-export function buildRequestPath(
-  route: Route,
-  args: Record<string, any>,
-): { path: string; remainingArgs: Record<string, any> } {
-  let finalPath = route.pathTemplate;
-  const remainingArgs = { ...args };
-
-  const pathMatches = finalPath.match(/\{([^}]+)\}/g);
-  if (pathMatches) {
-    pathMatches.forEach((match) => {
-      const key = match.replace(/[{}]/g, "");
-      if (remainingArgs[key] !== undefined) {
-        finalPath = finalPath.replace(
-          match,
-          encodeURIComponent(String(remainingArgs[key])),
-        );
-        delete remainingArgs[key];
-      }
-    });
-  }
-
-  if (route.method === "GET" && Object.keys(remainingArgs).length > 0) {
-    const params = new URLSearchParams();
-    for (const [key, value] of Object.entries(remainingArgs)) {
-      if (value !== undefined && value !== null) {
-        params.append(key, String(value));
-      }
-    }
-    const separator = finalPath.includes("?") ? "&" : "?";
-    finalPath += `${separator}${params.toString()}`;
-
-    for (const key of Object.keys(remainingArgs)) delete remainingArgs[key];
-  }
-
-  return { path: finalPath, remainingArgs };
-}

package/src/core/types.ts

@@ -1,49 +0,0 @@
-export interface AtmxContractConfig {
-  contractUrl: string;
-  baseUrl: string;
-}
-
-export interface AtmxConfig {
-  contracts: Record<string, AtmxContractConfig>;
-  debug?: boolean; // Enable verbose logging
-}
-
-export enum EventType {
-  Complete = 0,
-  NetworkSuccess = 1,
-  CacheHit = 2,
-  CacheHitAndFetching = 3,
-  Error = 4,
-}
-
-export interface AxiomError {
-  stage: string;
-  category: string;
-  code: string | Record<string, any>;
-  message: string;
-  retryable: boolean;
-  details?: string;
-}
-
-export interface AxiomResponse {
-  eventType: EventType;
-  data?: any;
-  error?: AxiomError;
-  isFetching?: boolean;
-  isStreamChunk?: boolean;
-}
-
-export interface InitResult {
-  ok: boolean;
-  error?: AxiomError;
-  contracts: Record<
-    string,
-    { loaded: boolean; endpointCount: number; error?: string }
-  >;
-  initDurationMs: number;
-}
-
-export interface ContractLoadedEvent {
-  namespace: string;
-  endpointCount: number;
-}

package/src/core/wasm.ts

@@ -1,223 +0,0 @@
-// FILE: src/core/wasm.ts
-import { setupWebCallback } from "./callback";
-import { AtmxConfig } from "../core/types";
-import { initRouter } from "./router";
-import { InitResult } from "./types";
-
-// @ts-ignore
-import wasmGlueCode from "./vendor/axiom_runtime.js?raw";
-
-export let wasmEngine: any = null;
-
-export function allocBytes(bytes: Uint8Array): number {
-  if (bytes.length === 0) return 0;
-  const ptr = wasmEngine.axiom_malloc(bytes.length);
-  const mem = new Uint8Array(wasmEngine.memory.buffer);
-  mem.set(bytes, ptr);
-  return ptr;
-}
-
-export function allocString(str: string): { ptr: number; len: number } {
-  if (!str) return { ptr: 0, len: 0 };
-  const bytes = new TextEncoder().encode(str);
-  const ptr = allocBytes(bytes);
-  return { ptr, len: bytes.length };
-}
-
-function getWasmUrl(): string {
-  return "https://atmx.axiomcore.dev/latest/axiom_runtime.wasm";
-}
-
-export async function initWasm(config: AtmxConfig): Promise<InitResult> {
-  const startTime = performance.now();
-  const result: InitResult = {
-    ok: false,
-    contracts: {},
-    initDurationMs: 0,
-  };
-
-  try {
-    if (!(window as any).wasm_bindgen) {
-      const script = document.createElement("script");
-      script.type = "text/javascript";
-      script.text = `${wasmGlueCode}\nwindow.wasm_bindgen = wasm_bindgen;`;
-      document.head.appendChild(script);
-    }
-
-    const wasmBindgen = (window as any).wasm_bindgen;
-    const wasmLocation = getWasmUrl();
-    const fetchUrl = `${wasmLocation}?t=${Date.now()}`;
-
-    try {
-      wasmEngine = await wasmBindgen(fetch(fetchUrl));
-    } catch (e: any) {
-      throw {
-        stage: "ffiBoundary",
-        category: "network",
-        code: "WasmFetchFailed",
-        message: `Failed to download WASM engine: ${e.message}`,
-        retryable: true,
-      };
-    }
-
-    setupWebCallback(wasmEngine);
-
-    setInterval(() => {
-      if (wasmEngine) wasmEngine.axiom_process_responses();
-    }, 16);
-
-    const dbPath = allocString("");
-    const initResultCode = wasmEngine.axiom_wasm_initialize(
-      dbPath.ptr,
-      dbPath.len,
-    );
-    wasmEngine.axiom_free_memory(dbPath.ptr, dbPath.len);
-
-    if (initResultCode !== 0) {
-      throw {
-        stage: "runtime",
-        category: "server",
-        code: "InitFailed",
-        message: `Engine init failed (Code: ${initResultCode})`,
-        retryable: false,
-      };
-    }
-
-    for (const [namespace, contractConfig] of Object.entries(
-      config.contracts,
-    )) {
-      try {
-        const contractRes = await fetch(contractConfig.contractUrl);
-        if (!contractRes.ok) {
-          throw new Error(`HTTP ${contractRes.status}`);
-        }
-
-        const contractArrayBuffer = await contractRes.arrayBuffer();
-        let endpointCount = 0;
-
-        try {
-          const jsonStr = new TextDecoder().decode(contractArrayBuffer);
-          const contractJson = JSON.parse(jsonStr);
-          const endpoints = contractJson?.ir?.endpoints;
-          if (endpoints) {
-            endpointCount = Array.isArray(endpoints)
-              ? endpoints.length
-              : Object.keys(endpoints).length;
-          }
-          initRouter(namespace, contractJson);
-        } catch (e) {
-          console.error(
-            `ATMX: Failed to parse .axiom contract for '${namespace}'`,
-            e,
-          );
-        }
-
-        const contractBytes = new Uint8Array(contractArrayBuffer);
-        const cPtr = allocBytes(contractBytes);
-        const nsStr = allocString(namespace);
-        const urlStr = allocString(contractConfig.baseUrl);
-
-        const loadResult = wasmEngine.axiom_wasm_load_contract(
-          nsStr.ptr,
-          nsStr.len,
-          urlStr.ptr,
-          urlStr.len,
-          cPtr,
-          contractBytes.length,
-          0,
-          0,
-          0,
-          0,
-        );
-
-        wasmEngine.axiom_free_memory(cPtr, contractBytes.length);
-        wasmEngine.axiom_free_memory(nsStr.ptr, nsStr.len);
-        wasmEngine.axiom_free_memory(urlStr.ptr, urlStr.len);
-
-        if (loadResult !== 0 && loadResult !== -1) {
-          throw new Error(`Load error (Code: ${loadResult})`);
-        }
-
-        if (config.debug) {
-          console.log(
-            `%c🔒 Axiom Contract Loaded: ${namespace} (${endpointCount} endpoints)`,
-            "color: #10b981; font-weight: bold;",
-          );
-        }
-
-        result.contracts[namespace] = { loaded: true, endpointCount };
-
-        // ✨ EVENT: Emit contract loaded
-        document.dispatchEvent(
-          new CustomEvent("atmx:contract-loaded", {
-            detail: { namespace, endpointCount },
-          }),
-        );
-      } catch (contractErr: any) {
-        result.contracts[namespace] = {
-          loaded: false,
-          endpointCount: 0,
-          error: contractErr.message,
-        };
-        console.error(`ATMX: Contract failed for ${namespace}`, contractErr);
-      }
-    }
-
-    result.ok = true;
-  } catch (fatalError: any) {
-    result.ok = false;
-    // Map native JS errors into structured AxiomErrors
-    result.error = fatalError.stage
-      ? fatalError
-      : {
-          stage: "runtime",
-          category: "unknown",
-          code: "FatalError",
-          message: fatalError.message || String(fatalError),
-          retryable: false,
-        };
-  }
-
-  result.initDurationMs = Math.round(performance.now() - startTime);
-  return result;
-}
-
-export function setAuthToken(
-  namespace: string,
-  methodName: string,
-  token: string,
-) {
-  if (!wasmEngine) return;
-  const nStr = allocString(namespace);
-  const mStr = allocString(methodName);
-  const tStr = allocString(token);
-
-  wasmEngine.axiom_wasm_set_auth_token(
-    nStr.ptr,
-    nStr.len,
-    mStr.ptr,
-    mStr.len,
-    tStr.ptr,
-    tStr.len,
-  );
-
-  wasmEngine.axiom_free_memory(nStr.ptr, nStr.len);
-  wasmEngine.axiom_free_memory(mStr.ptr, mStr.len);
-  wasmEngine.axiom_free_memory(tStr.ptr, tStr.len);
-}
-
-export function clearAuthToken(namespace: string, methodName: string) {
-  if (!wasmEngine) return;
-  const nStr = allocString(namespace);
-  const mStr = allocString(methodName);
-
-  wasmEngine.axiom_wasm_clear_auth_token(
-    nStr.ptr,
-    nStr.len,
-    mStr.ptr,
-    mStr.len,
-  );
-
-  wasmEngine.axiom_free_memory(nStr.ptr, nStr.len);
-  wasmEngine.axiom_free_memory(mStr.ptr, mStr.len);
-}

package/src/dom/components/engine-status.ts

@@ -1,62 +0,0 @@
-// FILE: src/dom/components/engine-status.ts
-
-export class AxEngineStatusElement extends HTMLElement {
-  constructor() {
-    super();
-  }
-
-  connectedCallback() {
-    const loadingText = this.getAttribute("loading-text") || "Initializing...";
-    const readyText = this.getAttribute("ready-text") || "Online";
-    const errorText = this.getAttribute("error-text") || "Failed to Connect";
-
-    // Initial state
-    this.renderState("loading", loadingText, "text-amber-500 animate-pulse");
-
-    // Listen for ATMX engine events globally
-    document.addEventListener("atmx:ready", () => {
-      this.renderState("ready", readyText, "text-green-600");
-    });
-
-    document.addEventListener("atmx:error", (e: Event) => {
-      const customEvent = e as CustomEvent;
-      // Check if this is a fatal initialization error vs a normal query error
-      if (customEvent.detail && customEvent.detail.stage === "runtime") {
-        this.renderState(
-          "error",
-          `${errorText}: ${customEvent.detail.message}`,
-          "text-red-600",
-        );
-      }
-    });
-  }
-
-  private renderState(state: string, text: string, defaultClasses: string) {
-    this.setAttribute("data-state", state);
-
-    // If developer is using raw ax-engine-status directly with inner HTML template matching, we allow it.
-    // Otherwise, we just swap the raw text node.
-    const stateElements = this.querySelectorAll(`[data-ax-when]`);
-
-    if (stateElements.length > 0) {
-      stateElements.forEach((el) => {
-        if (el.getAttribute("data-ax-when") === state) {
-          el.removeAttribute("hidden");
-        } else {
-          el.setAttribute("hidden", "");
-        }
-      });
-    } else {
-      // No custom inner templates, just replace text
-      this.innerText = text;
-      if (!this.getAttribute("class")) {
-        this.className = `text-xs font-bold ${defaultClasses}`;
-      }
-    }
-  }
-}
-
-// Automatically register the web component
-if (typeof window !== "undefined" && !customElements.get("ax-engine-status")) {
-  customElements.define("ax-engine-status", AxEngineStatusElement);
-}

package/src/dom/indicators.ts

@@ -1,36 +0,0 @@
-const activeRequests = new Map<number, { trigger: HTMLElement, indicators: HTMLElement[] }>();
-
-export function startRequest(reqId: number, triggerEl: HTMLElement) {
-    // 1. Add 'ax-request' to the element that triggered the call (e.g., the button)
-    triggerEl.classList.add('ax-request');
-
-    // 2. Find any associated loading indicators
-    let indicators: HTMLElement[] = [];
-    const indicatorSelector = triggerEl.getAttribute('ax-indicator');
-
-    if (indicatorSelector) {
-        // If ax-indicator="#spinner" is explicitly defined
-        indicators = Array.from(document.querySelectorAll(indicatorSelector));
-    } else {
-        // Fallback: Look for any children inside the trigger with the class 'ax-indicator'
-        indicators = Array.from(triggerEl.querySelectorAll('.ax-indicator'));
-    }
-
-    // 3. Turn on the indicators
-    indicators.forEach(el => el.classList.add('ax-loading'));
-
-    // 4. Save state so we can turn them off later
-    activeRequests.set(reqId, { trigger: triggerEl, indicators });
-}
-
-export function endRequest(reqId: number) {
-    const req = activeRequests.get(reqId);
-    if (!req) return;
-
-    // Turn off all classes
-    req.trigger.classList.remove('ax-request');
-    req.indicators.forEach(el => el.classList.remove('ax-loading'));
-
-    // Clean up
-    activeRequests.delete(reqId);
-}