Build Full-Stack & Native Mobile Apps at Agent Speed

import { defineConfig, loadPandConfig, resolveServicePort, allocateServicePorts } from "@pands/config";

export default defineConfig({
  name: "acme-cloud",
  pandVersion: "0.1.1",
  services: {
    core: { path: "services/core" },
    billing: { path: "services/billing" },
  },
  apps: {
    web: { path: "apps/web", framework: "nextjs" },
    admin: { path: "apps/admin", framework: "nextjs" },
    ios: { path: "ios", bundleId: "com.acme.cloud" },
    android: { path: "android", packageName: "com.acme.cloud" },
  },
  gateway: {
    port: 3000,
    corsOrigins: ["http://localhost:3001", "http://localhost:3002"],
    rateLimit: { windowMs: 60_000, max: 120 },
  },
});

import { createService, defineEntity, registerCrudRoutes } from "@pands/service";
import { createServiceDb, standardColumns } from "@pands/db";
import { z } from "zod";

const { db, schema } = createServiceDb("billing");

export const invoices = schema.table("invoices", {
  ...standardColumns(),
  customerId: schema.uuid("customer_id").notNull(),
  amountCents: schema.integer("amount_cents").notNull(),
  status: schema.varchar("status", { length: 32 }).notNull().default("draft"),
});

export const invoiceEntity = defineEntity({
  name: "invoice",
  plural: "invoices",
  table: invoices,
  createSchema: z.object({
    customerId: z.string().uuid(),
    amountCents: z.number().int().nonnegative(),
    status: z.enum(["draft", "open", "paid", "void"]).default("draft"),
  }),
});

export const service = createService({
  name: "billing",
  version: "0.1.1",
  db,
  entities: [invoiceEntity],
});

// Registers GET /, POST /, GET /:id, PATCH /:id, DELETE /:id with cursor pagination & OpenAPI 3.1 metadata
registerCrudRoutes(service.app, invoiceEntity, db);

import { createGateway, signInternalIdentity, verifyInternalIdentity } from "@pands/gateway";

const gateway = createGateway({
  services: {
    core: { url: "http://localhost:6300" },
    billing: { url: "http://localhost:4700" },
  },
  internalSecret: process.env.PAND_INTERNAL_SECRET!,
  corsOrigins: ["http://localhost:3001"],
  rateLimit: { windowMs: 60_000, max: 200 },
  resolveSession: async (req) => auth.verifyRequest(req),
});

import { createServiceDb, standardColumns, scopeToOrg, decodeCursor, encodeCursor } from "@pands/db";

const { db, pgSchema, close } = createServiceDb("core", process.env.DATABASE_URL);

// Multi-tenant row scoping helper:
const tenantFilter = scopeToOrg(projects.organizationId, ctx.var.identity?.orgId);
const rows = await db.select().from(projects).where(tenantFilter);

import { createPandAuth, createAuthClient } from "@pands/auth";

// Server setup (mounts /register, /login, /logout, /refresh, /me, /api-keys)
export const auth = createPandAuth({
  secret: process.env.PAND_AUTH_SECRET!,
  accessTokenTtlSeconds: 900,
  refreshTokenTtlSeconds: 60 * 60 * 24 * 30,
});

// Universal client for Web & React Native / Mobile
const authClient = createAuthClient({ baseUrl: "http://localhost:3000/api/v1/auth" });
const session = await authClient.login({ email: "dev@acme.io", password: "correct-horse-battery" });

import { mergeOpenApiSpecs, generateTypeScriptSdk, generateSwiftSdk, generateKotlinSdk } from "@pands/sdk-gen";

const merged = mergeOpenApiSpecs([
  { serviceName: "core", spec: coreOpenApi },
  { serviceName: "billing", spec: billingOpenApi },
]);

const tsCode = generateTypeScriptSdk(merged);
const swiftCode = generateSwiftSdk(merged);
const kotlinCode = generateKotlinSdk(merged, "com.acme.pand.sdk");

import { DataTable, AutoForm, Button } from "@pands/ui";
import { AdminDashboard } from "@pands/admin-ui";

// Render an entire multi-service Admin Console with search, pagination, and Zod-backed create/edit modals:
export default function AdminPage() {
  return <AdminDashboard gatewayUrl="http://localhost:3000" />;
}

// Swift (iOS) generated usage:
let client = PandClient(
    baseURL: URL(string: "https://api.acme.io")!,
    tokenStore: KeychainTokenStore(service: "com.acme.app")
)
let tasks = try await client.coreListTasks(limit: 25)
let created = try await client.coreCreateTask(input: CreateTaskInput(title: "Ship v1", done: false))

import { defineEvent, createEventBus } from "@pands/events";
import { z } from "zod";

export const InvoicePaid = defineEvent("billing.invoice.paid", z.object({
  invoiceId: z.string().uuid(),
  amountCents: z.number().int(),
}));

const bus = createEventBus({ driver: "memory" }); // or { driver: "bullmq", redisUrl: process.env.REDIS_URL }
bus.subscribe(InvoicePaid, async (payload) => {
  console.log("Invoice paid:", payload.invoiceId);
});
await bus.publish(InvoicePaid, { invoiceId: "550e8400-e29b-41d4-a716-446655440000", amountCents: 4900 });

import { createStorageClient } from "@pands/storage";

const storage = createStorageClient({
  driver: "s3", // or "memory" for unit tests
  endpoint: process.env.S3_ENDPOINT,
  bucket: "acme-uploads",
  region: "auto",
  accessKeyId: process.env.S3_ACCESS_KEY_ID!,
  secretAccessKey: process.env.S3_SECRET_ACCESS_KEY!,
});

await storage.putObject("avatars/u1.png", imageBuffer, "image/png");
const uploadUrl = await storage.presignUpload("avatars/u2.png", { expiresInSeconds: 300 });

import { createPushClient } from "@pands/push";
import { createAnalyticsClient } from "@pands/analytics";

const push = createPushClient({ driver: "expo", accessToken: process.env.EXPO_ACCESS_TOKEN });
await push.send({
  to: "ExponentPushToken[xxxxxxxxxxxxxxxxxxxxxx]",
  title: "Deployment Complete",
  body: "acme-cloud v0.1.1 is live.",
});

const analytics = createAnalyticsClient({ endpoint: "/api/v1/analytics/events", batchSize: 10 });
analytics.track("invoice_created", { amountCents: 9900 });
await analytics.flush();

import { createLogger } from "@pands/logger";
import { createMetricsRegistry } from "@pands/telemetry";
import { createTestContext, testService } from "@pands/testing";

const logger = createLogger({ service: "billing" });
logger.info({ invoiceId: "inv_123", apiKey: "secret" }, "Processed invoice"); // apiKey automatically "[REDACTED]"

// In Vitest integration tests:
const client = testService(service);
const res = await client.request("/invoices", {
  method: "POST",
  body: { customerId: "550e8400-e29b-41d4-a716-446655440000", amountCents: 2500 },
  identity: { sub: "user_1", roles: ["admin"], scopes: ["*"] },
});