Build scalable microservices, faster.

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

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

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

  @Get("get")
  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 sendProxy =
    InterfaceFunction<
      (p: EmailParams) => Promise<Result>
    >();
}

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

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

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

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

  @Hashed()
  declare password: string;

  declare name: string;
}

// CRUD via the data model
const model = getUserModel();
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";

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

// Custom admin-only decorator
const AdminAuth = CreateAuthDecorator({
  source(req) {
    return req.headers["authorization"]
      ?.replace("Bearer ", "");
  },
  async authenticator(token) {
    const p = await ValidateRaw(token);
    if (p.role !== "admin") throw new Error("Forbidden");
    return p;
  }
});

import { autoCRUD } from "@antelopejs/interface-api";
import { User } from "./tables/user";

// One line, full REST surface
autoCRUD(User, {
  basePath: "/api/users",
  auth: AdminAuth,
  list:    { paginate: true },
  create:  { schema: CreateUserDto },
  update:  { schema: UpdateUserDto },
  delete:  true
});

import { defineEvent, on, emit } from
  "@antelopejs/interface-events";

// 1. Declare the event
export const userCreated =
  defineEvent<{ id: string, email: string }>(
    "user.created"
  );

// 2. Emit from anywhere
await emit(userCreated, { id, email });

// 3. Subscribe in another module
on(userCreated, async ({ id, email }) => {
  await SendEmail({ to: email,
    subject: "Welcome" });
});

import { Logging } from "@antelopejs/interface-logging";

// Phase 1: Constructed
export async function construct(
  config: Config
) {
  // import all interface dependencies
  await importInterface("database");
  await importInterface("logging");
}

// Phase 2: All interfaces ready
export function start() {
  Logging.Info("Module active");
}

// Phase 3 & 4: Graceful shutdown
export async function stop() {}
export async function destroy() {}

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

export default defineConfig({
  name: "my-app",
  modules: {
    "@antelopejs/module-auth": "2.1.0",
    "api": {
      source: { type: "local",
        path: "./modules/api" },
      config: { port: 3000,
        url: "${host}:${port}" },
    },
    "db": "@antelopejs/[email protected]",
  },
  envOverrides: {
    "DB_HOST": "modules.db.config.host",
  },
});