Custom code: lambdas, microservices and HTTP calls

// xano/custom/native.ts
import { defineFunction, input, inp, ref, s, withFilters, fl } from "@xano/sdk";

export const withTax = defineFunction({
  name: "with_tax",
  input: { subtotal: input.decimal({ required: true }) },
  stack: [s.set_var("total", withFilters(inp("subtotal"), fl.mul(1.2), fl.round(2)))],
  response: ref("total"),
});

// xano/custom/lambda.ts
import { defineFunction, input, inp, ref, s, c, withFilters, fl } from "@xano/sdk";

export const orderTotal = defineFunction({
  name: "order_total",
  input: { lines: input.json({ required: true }) }, // [{ qty, price }, ...]
  stack: [
    s.set_var("lines", inp("lines")),
    s.lambda({
      as: "total",
      // the body is sent as text; bindings arrive as parameters
      code: ({ $var }) =>
        $var.lines.reduce((sum: number, l: { qty: number; price: number }) => sum + l.qty * l.price, 0),
    }),
  ],
  response: ref("total"),
});

export const doubled = defineFunction({
  name: "doubled",
  stack: [
    s.set_var("nums", c.array([1, 2, 3])),
    s.set_var("out", withFilters(ref("nums"), fl.map(({ $this }) => $this * 2))), // [2, 4, 6]
  ],
  response: ref("out"),
});

// xano/lambdas/order-total.ts
import type { LambdaBindings } from "@xano/sdk";

export default ({ $result, $this }: LambdaBindings<"reduce">) => {
  const line = $this.qty * $this.price;
  const discount = $this.qty >= 10 ? 0.1 : 0;
  return $result + line * (1 - discount);
};

// xano/custom/lambda-file.ts
import { defineFunction, input, inp, ref, s, withFilters, fl } from "@xano/sdk";
import { lam } from "@xano/sdk/node";

export const bulkTotal = defineFunction({
  name: "bulk_total",
  input: { lines: input.json({ required: true }) },
  stack: [
    s.set_var(
      "total",
      withFilters(inp("lines"), fl.reduce({ initial_value: 0, code: lam.file("../lambdas/order-total.ts") })),
    ),
  ],
  response: ref("total"),
});

// xano/custom/http.ts
import { defineFunction, input, inp, ref, s, c, expr, env } from "@xano/sdk";

export const lookupCompany = defineFunction({
  name: "lookup_company",
  input: { domain: input.text({ required: true }) },
  stack: [
    s.api.request({
      as: "company",
      method: "GET",
      url: "https://api.example.com/v1/companies",
      params: { domain: inp("domain") },
      headers: {
        "User-Agent": "my-app",
        Authorization: env("COMPANY_API_KEY"),
      },
      timeout: 10,
    }),
    s.precondition({
      expr: expr(ref("company.response.status"), "=", c.int(200)),
      error: c.text("The company lookup failed."),
      error_type: "badrequest",
    }),
  ],
  response: ref("company.response.result"), // never return the whole envelope: it echoes your headers
});

// xano/custom/microservice.ts
import { microservice, defineFunction, ref, s, c } from "@xano/sdk";

export const pdfRenderer = microservice({
  name: "pdf_renderer",
  deployment: {
    replicas: 1,
    containers: [
      {
        name: "renderer",
        image: "ealen/echo-server:latest",
        ports: [{ servicePort: "8080", containerPort: "80" }],
        resources: { cpu: "250m", ram: "512Mi" },
        env: [
          { name: "MODE", value: "production" },
          { name: "LICENSE_KEY", fromEnv: "PDF_LICENSE_KEY" }, // only the name travels in the bundle
        ],
      },
    ],
  },
});

export const renderPdf = defineFunction({
  name: "render_pdf",
  stack: [
    s.microservice.request({
      as: "rendered",
      host: pdfRenderer, // binds by name; the one servicePort resolves on its own
      path: c.text("/render"),
      method: "POST",
      params: c.obj({ template: "invoice" }),
    }),
  ],
  response: ref("rendered.response.result"),
});

export default workspace("my-app")
  // ...tables, API groups, queries
  .registerFunctions([withTax, orderTotal, doubled, bulkTotal, lookupCompany, renderPdf])
  .registerMicroservices([pdfRenderer]);