Functions

import { Function, OntologyObjectSet, Integer, Double } from "@osdk/functions";
import { SupplyOrder, Warehouse } from "@my-ontology/osdk";

export interface WarehouseFillRate {
  warehouseId: string;
  totalOrders: Integer;
  pendingOrders: Integer;
  fillRate: Double;
}

@Function()
export async function computeWarehouseFillRates(
  warehouseRegion: string
): Promise<WarehouseFillRate[]> {
  const warehouses = await Warehouse.where({
    region: { $eq: warehouseRegion },
  }).fetchPage({ pageSize: 100 });

  const results: WarehouseFillRate[] = [];

  for (const warehouse of warehouses.data) {
    const allOrders = SupplyOrder.where({
      warehouseId: { $eq: warehouse.warehouseId },
    });

    const [total, pending] = await Promise.all([
      allOrders.aggregate({ $count: true }),
      allOrders
        .where({ status: { $eq: "PENDING" } })
        .aggregate({ $count: true }),
    ]);

    results.push({
      warehouseId: warehouse.warehouseId,
      totalOrders: total.$count,
      pendingOrders: pending.$count,
      fillRate:
        total.$count > 0
          ? (total.$count - pending.$count) / total.$count
          : 0,
    });
  }

  return results;
}

import {
  Function,
  OntologyEditFunction,
  Query,
  Parameter,
  Edits,
  Integer,
} from "@foundry/functions-api";
import { Order, ObjectSet } from "@foundry/ontology-api";

@Function()
export class OrderManagement {
  @Query()
  async getOpenOrdersForCustomer(
    @Parameter({ description: "Customer identifier" }) customerId: string
  ): Promise<Order[]> {
    return Objects.search()
      .order()
      .filter((order) => order.customerId.exactMatch(customerId))
      .filter((order) => order.status.exactMatch("OPEN"))
      .all();
  }

  @OntologyEditFunction()
  async closeOrder(
    @Parameter({ description: "Order to close" }) order: Order,
    @Parameter({ description: "Closing reason" }) reason: string
  ): Promise<void> {
    order.status = "CLOSED";
    order.closingReason = reason;
    order.closedAt = new Date().toISOString();
  }

  @OntologyEditFunction()
  async bulkCloseOrders(
    @Parameter({ description: "Orders to close" }) orders: ObjectSet<Order>,
    @Parameter({ description: "Closing reason" }) reason: string
  ): Promise<Integer> {
    const orderList = await orders.all();
    for (const order of orderList) {
      order.status = "CLOSED";
      order.closingReason = reason;
      order.closedAt = new Date().toISOString();
    }
    return orderList.length;
  }
}

from functions import function
from foundry import FoundryClient
from ontology_sdk import SupplyOrder, Warehouse
from datetime import date
from typing import List
from dataclasses import dataclass

@dataclass
class RegionSummary:
    region: str
    open_order_count: int
    total_value: float
    oldest_order_date: str

@function
def summarize_open_orders_by_region(
    region: str,
    as_of_date: date,
) -> List[RegionSummary]:
    client = FoundryClient()

    warehouses = (
        client.objects.Warehouse
        .filter(Warehouse.region == region)
        .iterate()
    )

    results = []
    for warehouse in warehouses:
        orders = list(
            client.objects.SupplyOrder
            .filter(SupplyOrder.warehouse_id == warehouse.warehouse_id)
            .filter(SupplyOrder.status == "OPEN")
            .filter(SupplyOrder.created_date <= as_of_date)
            .iterate()
        )

        if not orders:
            continue

        results.append(
            RegionSummary(
                region=region,
                open_order_count=len(orders),
                total_value=sum(o.order_value or 0.0 for o in orders),
                oldest_order_date=str(min(o.created_date for o in orders)),
            )
        )

    return results

// In the Ontology Builder, the Action Type "adminDeleteStaleDrafts" is configured
// with project-scoped execution. The TypeScript function below is backed by that Action.
// Regular users trigger the Action; the function runs with project permissions.

import { Function, OntologyEditFunction, Parameter } from "@foundry/functions-api";
import { DraftOrder, ObjectSet } from "@foundry/ontology-api";

// This function runs with PROJECT permissions, not the triggering user's permissions.
// The Ontology Builder > Action Type > Execution Scope must be set to "Project" for this
// to take effect. Do not set project-scoped execution unless the workflow explicitly
// requires the function to access data the triggering user cannot access directly.

@Function()
export class AdminOrderCleanup {
  @OntologyEditFunction()
  async deleteStaleAdminDrafts(
    @Parameter({ description: "Cutoff date for stale drafts (ISO string)" })
    cutoffDateIso: string
  ): Promise<void> {
    const cutoff = new Date(cutoffDateIso);

    const staleDrafts: ObjectSet<DraftOrder> = Objects.search()
      .draftOrder()
      .filter((d) => d.status.exactMatch("DRAFT"))
      .filter((d) => d.createdAt.lt(cutoff.toISOString()));

    const drafts = await staleDrafts.all();
    for (const draft of drafts) {
      draft.status = "DELETED";
      draft.deletedAt = new Date().toISOString();
    }
  }
}

import { createStub, createObjectSet } from "@osdk/functions-testing";
import { SupplyOrder, Warehouse } from "@my-ontology/osdk";
import { computeWarehouseFillRates } from "../src/computeWarehouseFillRates";

describe("computeWarehouseFillRates", () => {
  it("returns correct fill rates for a given region", async () => {
    const warehouse1 = createStub(Warehouse, {
      warehouseId: "WH-001",
      region: "APAC",
    });

    const order1 = createStub(SupplyOrder, {
      orderId: "ORD-1",
      warehouseId: "WH-001",
      status: "FULFILLED",
    });
    const order2 = createStub(SupplyOrder, {
      orderId: "ORD-2",
      warehouseId: "WH-001",
      status: "PENDING",
    });
    const order3 = createStub(SupplyOrder, {
      orderId: "ORD-3",
      warehouseId: "WH-001",
      status: "FULFILLED",
    });

    // Register stubs so the ObjectSet API returns them
    const warehouseSet = createObjectSet(Warehouse, [warehouse1]);
    const orderSet = createObjectSet(SupplyOrder, [order1, order2, order3]);

    jest
      .spyOn(Warehouse, "where")
      .mockReturnValue(warehouseSet as any);
    jest
      .spyOn(SupplyOrder, "where")
      .mockReturnValue(orderSet as any);

    const results = await computeWarehouseFillRates("APAC");

    expect(results).toHaveLength(1);
    expect(results[0].warehouseId).toBe("WH-001");
    expect(results[0].totalOrders).toBe(3);
    expect(results[0].pendingOrders).toBe(1);
    expect(results[0].fillRate).toBeCloseTo(0.6667, 3);
  });

  it("returns fill rate of 0 for a warehouse with no orders", async () => {
    const warehouse = createStub(Warehouse, {
      warehouseId: "WH-002",
      region: "EMEA",
    });

    jest
      .spyOn(Warehouse, "where")
      .mockReturnValue(createObjectSet(Warehouse, [warehouse]) as any);
    jest
      .spyOn(SupplyOrder, "where")
      .mockReturnValue(createObjectSet(SupplyOrder, []) as any);

    const results = await computeWarehouseFillRates("EMEA");

    expect(results[0].fillRate).toBe(0);
  });
});