Standalone apps, CLI commands and the REPL

TypeScript (close-day.ts) · ops/src/close-day.ts

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module.js';
import { OrdersController, OrdersModule, OrdersService } from './orders.js';

// node dist/close-day.js --at <ISO time>: closes the lunch day of that instant, as a cron job would at 10:30 IST.
const at = new Date(process.argv[process.argv.indexOf('--at') + 1] ?? '');

const app = await NestFactory.createApplicationContext(AppModule, { logger: ['error', 'warn'] });
try {
  for (const line of app.select(OrdersModule).get(OrdersService, { strict: true }).closeDay(at)) console.log(line);
  // A controller is built too, but no route exists, and calling it directly skips the global interceptor.
  console.log(`OrdersController.list() called directly: ${JSON.stringify(app.get(OrdersController).list())}`);
} catch (e) {
  console.error((e as Error).message);
  process.exitCode = 1;
} finally {
  await app.close();
}

TypeScript (orders.ts) · ops/src/orders.ts

import { Controller, Get, Injectable, Module, type OnApplicationShutdown, type OnModuleInit } from '@nestjs/common';

export interface Order {
  id: number;
  kitchenId: string;
  /** When the customer placed it, in UTC. */
  placedAt: string;
  paise: number;
  status: 'placed' | 'sent-to-kitchen' | 'moved-to-tomorrow';
}

/** India Standard Time is UTC+05:30 all year. */
const IST_OFFSET_MS = (5 * 60 + 30) * 60_000;

/** The lunch day an instant belongs to, as YYYY-MM-DD in IST. */
export function istDay(at: Date): string {
  return new Date(at.getTime() + IST_OFFSET_MS).toISOString().slice(0, 10);
}

/** The lunch cut-off of a day: 10:30 IST, which is 05:00 UTC. */
export function cutOffOf(day: string): Date {
  return new Date(Date.parse(`${day}T10:30:00Z`) - IST_OFFSET_MS);
}

/** Stands for the orders table: six orders of one morning, loaded at start-up. */
@Injectable()
export class OrdersRepository implements OnModuleInit, OnApplicationShutdown {
  orders: Order[] = [];

  onModuleInit() {
    this.orders = [
      { id: 301, kitchenId: 'pune-07', placedAt: '2026-09-16T23:40:00Z', paise: 12000, status: 'placed' },
      { id: 302, kitchenId: 'pune-07', placedAt: '2026-09-17T02:15:00Z', paise: 12000, status: 'placed' },
      { id: 303, kitchenId: 'pune-12', placedAt: '2026-09-17T03:05:00Z', paise: 9500, status: 'placed' },
      { id: 304, kitchenId: 'pune-07', placedAt: '2026-09-17T04:20:00Z', paise: 15000, status: 'placed' },
      { id: 305, kitchenId: 'pune-12', placedAt: '2026-09-17T04:59:00Z', paise: 9500, status: 'placed' },
      { id: 306, kitchenId: 'pune-07', placedAt: '2026-09-17T05:07:00Z', paise: 12000, status: 'placed' },
    ];
    console.log(`orders loaded: ${this.orders.length}`);
  }

  onApplicationShutdown() {
    console.log('orders saved, connection closed');
  }
}

@Injectable()
export class OrdersService {
  constructor(private readonly repo: OrdersRepository) {}

  /** Sends the day's orders placed before the cut-off to the kitchens, and moves later ones to the next day. */
  closeDay(now: Date): string[] {
    if (Number.isNaN(now.getTime())) throw new Error('close-day: --at must be an ISO time such as 2026-09-17T05:00:00Z');
    const day = istDay(now);
    const cutOff = cutOffOf(day);
    if (now < cutOff) return [`${day}: still open, ${Math.round((cutOff.getTime() - now.getTime()) / 60_000)} minutes to the 10:30 IST cut-off`];
    const perKitchen = new Map<string, number>();
    const moved: number[] = [];
    for (const order of this.repo.orders) {
      if (order.status !== 'placed' || istDay(new Date(order.placedAt)) !== day) continue;
      if (new Date(order.placedAt) < cutOff) {
        order.status = 'sent-to-kitchen';
        perKitchen.set(order.kitchenId, (perKitchen.get(order.kitchenId) ?? 0) + 1);
      } else {
        order.status = 'moved-to-tomorrow';
        moved.push(order.id);
      }
    }
    return [
      `${day}: closed at the 10:30 IST cut-off (${cutOff.toISOString()})`,
      ...[...perKitchen].map(([kitchen, n]) => `   ${kitchen}: ${n} lunches sent to the kitchen`),
      `   moved to tomorrow: ${moved.length ? moved.join(', ') : 'none'}`,
    ];
  }

  /** The orders of a kitchen placed before the cut-off of a day, as the kitchen's display received them. */
  sentToKitchen(kitchenId: string, day: string): Order[] {
    const cutOff = cutOffOf(day);
    return this.repo.orders.filter(
      (o) => o.kitchenId === kitchenId && istDay(new Date(o.placedAt)) === day && new Date(o.placedAt) < cutOff,
    );
  }

  /** Lunches per kitchen for a day, placed before its cut-off. */
  lunchesPerKitchen(day: string): Map<string, number> {
    const counts = new Map<string, number>();
    for (const kitchen of new Set(this.repo.orders.map((o) => o.kitchenId))) counts.set(kitchen, this.sentToKitchen(kitchen, day).length);
    return counts;
  }
}

@Controller('orders')
export class OrdersController {
  constructor(private readonly repo: OrdersRepository) {}

  @Get()
  list() {
    return this.repo.orders.map((o) => o.id);
  }
}

@Module({ controllers: [OrdersController], providers: [OrdersRepository, OrdersService], exports: [OrdersService] })
export class OrdersModule {}