Objekttypen im Zusammenspiel; Projekt: ein typisierter Bestandslader

export interface Product {
  readonly sku: string;
  name: string;
  price: number;
  note: string;
}

export interface Item extends Product {
  location: [string, number];
  tags: string[];
  stock: number;
}

export function totalStock(item: Item): number {
  return item.stock;
}

export function stockValue(items: readonly Item[]): number {
  let value = 0;
  for (const item of items) value += item.price * totalStock(item);
  return value;
}

export const lamp: Item = {
  sku: "L-1",
  name: "Desk lamp",
  price: 25,
  location: ["A", 3],
  tags: ["light"],
  stock: { berlin: 4, bonn: 2 }
};

function noEdits(item: Item) {
  // @ts-expect-error: tags are read-only
  item.tags.push("sale");
  // @ts-expect-error: the stock is read-only
  item.stock.berlin = 0;
  // @ts-expect-error: a location cannot change
  item.location[1] = 4;
}

import {test} from 'node:test';
import assert from 'node:assert/strict';
import {totalStock, stockValue, lamp} from './main.ts';

const chair = {sku: 'C-7', name: 'Chair', price: 80, location: ['B', 1] as const, tags: [], stock: {berlin: 1}};
const empty = {sku: 'E-0', name: 'Empty box', price: 2, location: ['C', 2] as const, tags: [], stock: {}};

test('totalStock addiert die Bestände aller Lager', () => {
  assert.equal(totalStock(lamp), 6, `totalStock(lamp) ergab ${totalStock(lamp)}`);
});

test('ein Artikel ohne Bestandseinträge hat den Bestand 0', () => {
  assert.equal(totalStock(empty), 0, `totalStock(empty) ergab ${totalStock(empty)}`);
});

test('stockValue addiert Preis mal Bestand über alle Artikel', () => {
  const got = stockValue([lamp, chair, empty]);
  assert.equal(got, 230, `stockValue([lamp, chair, empty]) ergab ${got}`);
});

{
  "type": "module"
}

{
  "compilerOptions": {
    "target": "esnext",
    "module": "nodenext",
    "lib": [
      "esnext",
      "dom"
    ],
    "types": [],
    "strict": true,
    "noEmit": true,
    "erasableSyntaxOnly": true,
    "verbatimModuleSyntax": true,
    "allowImportingTsExtensions": true
  },
  "include": [
    "**/*.ts"
  ],
  "exclude": [
    "**/*.test.ts"
  ]
}

export interface Product {
  readonly sku: string;
  name: string;
  price: number;
  note?: string;
}

export interface Stock {
  readonly [warehouse: string]: number;
}

export type Location = readonly [string, number];

export interface Item extends Product {
  location: Location;
  tags: readonly string[];
  stock: Stock;
}

function fail(message: string): never {
  throw new Error(message);
}

function isRecord(value: unknown): value is { [key: string]: unknown } {
  return typeof value === "object" && value !== null && !Array.isArray(value);
}

export function isLocation(value: unknown): boolean {
  return Array.isArray(value);
}

export function isStock(value: unknown): boolean {
  return isRecord(value);
}

export function parseItem(value: unknown): Item {
  if (!isRecord(value)) fail("an item must be an object");
  const { sku, name, price, location, tags, stock } = value;
  if (typeof sku !== "string") fail("sku must be a string");
  if (typeof name !== "string") fail("name must be a string");
  if (typeof price !== "number") fail("price must be a number");
  if (!isLocation(location)) fail("location must be [aisle, shelf]");
  if (!isStock(stock)) fail("stock must map warehouses to numbers");
  return { sku, name, price, location, tags, stock };
}

import {test} from 'node:test';
import assert from 'node:assert/strict';
import {isLocation, isStock, parseItem} from './main.ts';

const lamp = {sku: 'L-1', name: 'Desk lamp', price: 25, location: ['A', 3], tags: ['light'], stock: {berlin: 4, bonn: 2}};

test('isLocation akzeptiert einen Gang und ein Regal, sonst nichts', () => {
  assert.equal(isLocation(['A', 3]), true, "isLocation(['A', 3]) sollte true sein");
  assert.equal(isLocation(['A', '3']), false, "isLocation(['A', '3']) sollte false sein: das Regal ist eine Zahl");
  assert.equal(isLocation(['A', 3, 1]), false, "isLocation(['A', 3, 1]) sollte false sein: genau zwei Teile");
});

test('isStock akzeptiert nur Zahlen pro Lager', () => {
  assert.equal(isStock({berlin: 4}), true, 'isStock({berlin: 4}) sollte true sein');
  assert.equal(isStock({berlin: 'four'}), false, "isStock({berlin: 'four'}) sollte false sein");
  assert.equal(isStock([4]), false, 'isStock([4]) sollte false sein: ein Array ist keine Zuordnung von Lagern');
});

test('ein gültiger Artikel kommt mit allen Eigenschaften zurück', () => {
  assert.deepEqual(parseItem(lamp), lamp, 'parseItem(lamp) sollte ein Objekt gleich lamp zurückgeben');
});

test('tags muss ein Array von Strings sein', () => {
  assert.throws(() => parseItem({...lamp, tags: ['light', 7]}), {message: 'tags must be strings'}, 'ein Tag 7 sollte "tags must be strings" werfen');
});

test('ein falscher Ort oder Bestand wird mit seiner Meldung abgelehnt', () => {
  assert.throws(() => parseItem({...lamp, location: ['A']}), {message: 'location must be [aisle, shelf]'}, "location ['A'] sollte \"location must be [aisle, shelf]\" werfen");
  assert.throws(() => parseItem({...lamp, stock: {berlin: '4'}}), {message: 'stock must map warehouses to numbers'}, "stock {berlin: '4'} sollte \"stock must map warehouses to numbers\" werfen");
});

{
  "type": "module"
}

{
  "compilerOptions": {
    "target": "esnext",
    "module": "nodenext",
    "lib": [
      "esnext",
      "dom"
    ],
    "types": [],
    "strict": true,
    "noEmit": true,
    "erasableSyntaxOnly": true,
    "verbatimModuleSyntax": true,
    "allowImportingTsExtensions": true
  },
  "include": [
    "**/*.ts"
  ],
  "exclude": [
    "**/*.test.ts"
  ]
}

export interface Product {
  readonly sku: string;
  name: string;
  price: number;
  note?: string;
}

export interface Stock {
  readonly [warehouse: string]: number;
}

export type Location = readonly [string, number];

export interface Item extends Product {
  location: Location;
  tags: readonly string[];
  stock: Stock;
}

export interface Inventory {
  readonly updated: string;
  readonly items: readonly Item[];
}

function fail(message: string): never {
  throw new Error(message);
}

function isRecord(value: unknown): value is { [key: string]: unknown } {
  return typeof value === "object" && value !== null && !Array.isArray(value);
}

function isLocation(value: unknown): value is Location {
  return Array.isArray(value) && value.length === 2 && typeof value[0] === "string" && typeof value[1] === "number";
}

function isStock(value: unknown): value is Stock {
  return isRecord(value) && Object.values(value).every((count) => typeof count === "number");
}

function isStringArray(value: unknown): value is readonly string[] {
  return Array.isArray(value) && value.every((tag) => typeof tag === "string");
}

export function parseItem(value: unknown): Item {
  if (!isRecord(value)) fail("an item must be an object");
  const { sku, name, price, location, tags, stock } = value;
  if (typeof sku !== "string") fail("sku must be a string");
  if (typeof name !== "string") fail("name must be a string");
  if (typeof price !== "number") fail("price must be a number");
  if (!isLocation(location)) fail("location must be [aisle, shelf]");
  if (!isStringArray(tags)) fail("tags must be strings");
  if (!isStock(stock)) fail("stock must map warehouses to numbers");
  return { sku, name, price, location, tags, stock };
}

export function totalStock(item: Item): number {
  let total = 0;
  for (const count of Object.values(item.stock)) total += count;
  return total;
}

export function parseInventory(text: string): Inventory {
  const raw = JSON.parse(text);
  return { updated: raw.updated, items: raw.items };
}

export function lowStock(inventory: Inventory, limit: number): readonly string[] {
  const sorted = inventory.items.sort((a, b) => a.sku.localeCompare(b.sku));
  return sorted.filter((item) => totalStock(item) <= limit).map((item) => item.sku);
}

import {test} from 'node:test';
import assert from 'node:assert/strict';
import {parseInventory, lowStock} from './main.ts';

const item = (sku, berlin) => ({sku, name: sku, price: 1, location: ['A', 1], tags: [], stock: {berlin}});
const text = JSON.stringify({updated: '2026-10-04', items: [item('L-1', 6), item('C-7', 1), item('B-2', 3)]});

test('ein gültiger Bestand wird mit allen Artikeln geladen', () => {
  const inventory = parseInventory(text);
  assert.equal(inventory.updated, '2026-10-04', `updated ist ${JSON.stringify(inventory.updated)}`);
  assert.deepEqual(inventory.items.map((i) => i.sku), ['L-1', 'C-7', 'B-2'], 'die drei Artikel sollten in ihrer Reihenfolge geladen werden');
});

test('der Bestand selbst wird geprüft', () => {
  assert.throws(() => parseInventory('null'), {message: 'the inventory must be an object'}, 'null sollte "the inventory must be an object" werfen');
  assert.throws(() => parseInventory('{"updated": "2026-10-04", "items": 3}'), {message: 'items must be an array'}, 'items: 3 sollte "items must be an array" werfen');
});

test('auch jeder Artikel wird geprüft', () => {
  const bad = JSON.stringify({updated: '2026-10-04', items: [{...item('X-1', 1), price: 'cheap'}]});
  assert.throws(() => parseInventory(bad), {message: 'price must be a number'}, 'ein Artikel mit price "cheap" sollte "price must be a number" werfen');
});

test('lowStock listet die SKUs bis zur Grenze, sortiert', () => {
  const got = lowStock(parseInventory(text), 3);
  assert.deepEqual(got, ['B-2', 'C-7'], `lowStock(inventory, 3) ergab ${JSON.stringify(got)}`);
});

test('lowStock lässt die Reihenfolge der Artikel unverändert', () => {
  const inventory = parseInventory(text);
  lowStock(inventory, 3);
  assert.deepEqual(inventory.items.map((i) => i.sku), ['L-1', 'C-7', 'B-2'], 'nach lowStock sollten die Artikel noch in ihrer Reihenfolge sein');
});

{
  "type": "module"
}

{
  "compilerOptions": {
    "target": "esnext",
    "module": "nodenext",
    "lib": [
      "esnext",
      "dom"
    ],
    "types": [],
    "strict": true,
    "noEmit": true,
    "erasableSyntaxOnly": true,
    "verbatimModuleSyntax": true,
    "allowImportingTsExtensions": true
  },
  "include": [
    "**/*.ts"
  ],
  "exclude": [
    "**/*.test.ts"
  ]
}