Build scalable microservices, faster.

import { Controller, Get, Post, Parameter,
  JSONBody, HTTPResult } from
  "@antelopejs/interface-api";

class UserController extends Controller("/api/users") {

  @Get("list")
  async listUsers() {
    return { users: [] };
  }

  @Get(":id")
  async getUser(@Parameter("id") id: string) {
    return { id, name: "Alice" };
  }

  @Post("create")
  async createUser(@JSONBody() body: any) {
    return new HTTPResult(201, body);
  }
}

// 1. Declare the contract
import { InterfaceFunction } from
  "@antelopejs/interface-core";

export namespace internal {
  export const sendEmailProxy =
    InterfaceFunction<
      (p: EmailParams) => Promise<Result>
    >();
}

export function SendEmail(p: EmailParams)
  : Promise<Result> {
  return internal.sendEmailProxy(p);
}

// 2. Consume it — that's it
import { SendEmail } from "@org/email";
await SendEmail({ to, subject, body });

import { Table, RegisterTable, Index, Field,
  Hashed, HashModifier, BasicDataModel,
  GetModel } from
  "@antelopejs/interface-database-decorators";

@RegisterTable("users", "main")
class User extends Table.with(HashModifier) {
  @Index() @Field("string")
  declare email: string;

  @Hashed() @Field("string")
  declare password: string;

  @Field("string")
  declare name: string;
}

// CRUD via the data model
const UserModel = BasicDataModel(User);
const model = GetModel(UserModel);
const [id] = await model.insert({ name, email, password });
const user = await model.get(id);
await model.update(id, { name });
await model.delete(id);

import { SignRaw, ValidateRaw,
  CreateAuthDecorator } from
  "@antelopejs/interface-auth";
import { HTTPResult } from
  "@antelopejs/interface-api";

interface Session { userId: string; role: string }

// Sign & validate tokens
const token = await SignRaw(
  { userId: "123", role: "admin" },
  { expiresIn: "24h" }
);
const payload = await ValidateRaw<Session>(token);

// Custom admin-only decorator
const AdminAuth = CreateAuthDecorator<Session, Session>({
  source: (req) =>
    req.headers.authorization
      ?.replace("Bearer ", ""),
  validator: (user) => {
    if (user?.role !== "admin")
      throw new HTTPResult(403, "Forbidden");
    return user;
  },
});

import { DataController, RegisterDataController,
  DefaultRoutes } from "@antelopejs/interface-data-api";
import { Access, AccessMode, Listable, Mandatory,
  ModelReference } from "@antelopejs/interface-data-api/metadata";
import { Model } from "@antelopejs/interface-database-decorators";
import { Controller } from "@antelopejs/interface-api";
import { User, UserModel } from "../db/tables/user";

// One class → the full CRUD surface for a table
@RegisterDataController()
class UserAPI extends DataController(
  User,
  DefaultRoutes.All,
  Controller("/api/users"),
) {
  @ModelReference() @Model(UserModel)
  declare userModel: UserModel;

  // Which fields the endpoints expose
  @Listable() @Access(AccessMode.ReadOnly)
  declare _id: string;
  @Listable() @Access(AccessMode.ReadWrite) @Mandatory("new")
  declare email: string;
  @Access(AccessMode.WriteOnly) @Mandatory("new")
  declare password: string;
}

import { EventProxy } from
  "@antelopejs/interface-core";

interface User { id: string; email: string }

// 1. Declare the typed event
export const userCreated =
  new EventProxy<(user: User) => void>();

// 2. Broadcast to every handler
userCreated.emit({ id, email });

// 3. Subscribe from another module
userCreated.register((user) => {
  SendEmail({ to: user.email,
    subject: "Welcome" });
});

import { ImplementInterface } from
  "@antelopejs/interface-core";
import { RegisterSchema } from
  "@antelopejs/interface-database-decorators";

// Phase 1 — Constructed: store config and register
// the interfaces this module implements.
export async function construct(config: Config) {
  void ImplementInterface(
    await import("@antelopejs/interface-email"),
    await import("./implementations/email"),
  );
}

// Phase 2 — Active: all interfaces resolved.
export async function start() {
  await RegisterSchema("main");
}

// Phase 3 & 4 — Graceful shutdown, in reverse.
export async function stop() {}
export function destroy() {}

import { defineConfig } from
  "@antelopejs/interface-core/config";

export default defineConfig({
  name: "my-app",
  modules: {
    // key = npm package, value = version
    "@antelopejs/auth-jwt": "^1.0.0",
    "api": {
      source: { type: "local",
        path: "./modules/api" },
      config: { port: 3000,
        url: "${host}:${port}" },
    },
    "db": { source: { type: "package",
      package: "@antelopejs/mongodb",
      version: "^1.2.0" } },
  },
  envOverrides: {
    "DB_HOST": "modules.db.config.host",
  },
});