Typen erweitern und Intersections

export interface Account {
  readonly id: number;
  email: string;
  plan: string;
}

export interface Admin extends Account {
  plan: number;
  permissions: string[];
}

export function summary(admin: Admin): string {
  return admin.email + " (" + admin.plan + ", " + admin.permissions.length + " permissions)";
}

export function canDelete(admin: Admin): boolean {
  return false;
}

// @ts-expect-error: an admin's plan is "team" or "enterprise"
const wrong: Admin = { id: 9, email: "eve@example.com", plan: "free", permissions: [] };

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

const ada = {id: 1, email: 'ada@example.com', plan: 'team' as const, permissions: ['read', 'delete']};
const bob = {id: 2, email: 'bob@example.com', plan: 'enterprise' as const, permissions: ['read']};

test('summary zeigt die E-Mail, den Plan und die Zahl der Berechtigungen', () => {
  const got = summary(ada);
  assert.equal(got, 'ada@example.com (team, 2 permissions)', `summary(ada) ergab ${JSON.stringify(got)}`);
});

test('ein Admin mit der Berechtigung delete darf löschen', () => {
  assert.equal(canDelete(ada), true, 'canDelete(ada) sollte true sein: ada hat "delete"');
});

test('ein Admin ohne sie darf es nicht', () => {
  assert.equal(canDelete(bob), false, 'canDelete(bob) sollte false sein: bob hat nur "read"');
});

{
  "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 type Titled = { title: string };
export type Timestamped = { createdAt: string };
export type Versioned = { version: number; createdAt: number };

export type Doc = Titled & Timestamped & Versioned;

export function label(doc: Doc): string {
  return doc.title + " v" + doc.version + " (created " + doc.createdAt + ")";
}

export function bump(doc: Doc, savedAt: string): Doc {
  return { ...doc, version: doc.version + 1 };
}

export const notes: Doc = { title: "Notes", version: 2, createdAt: "2026-10-01" };

import {test} from 'node:test';
import assert from 'node:assert/strict';
import {label, bump, notes} from './main.ts';

test('label zeigt die Version und wann das Dokument erstellt und gespeichert wurde', () => {
  const got = label(notes);
  assert.equal(got, 'Notes v2 (created 2026-10-01, saved 2026-10-03)', `label(notes) ergab ${JSON.stringify(got)}`);
});

test('bump erhöht die Version und hält fest, wann gespeichert wurde', () => {
  const got = bump(notes, '2026-10-04');
  assert.deepEqual(
    got,
    {title: 'Notes', version: 3, createdAt: '2026-10-01', savedAt: '2026-10-04'},
    `bump(notes, '2026-10-04') ergab ${JSON.stringify(got)}`
  );
});

test('bump lässt das ursprüngliche Dokument unverändert', () => {
  bump(notes, '2026-10-04');
  assert.equal(notes.version, 2, `notes.version ist nach bump ${notes.version}, aber bump sollte ein neues Dokument zurückgeben`);
});

{
  "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"
  ]
}