Klasse in Definitionsdatei importieren (* d.ts)

Ich möchte die Express-Sitzungstypisierung erweitern, um die Verwendung meiner benutzerdefinierten Daten im Sitzungsspeicher zu ermöglichen. Ich habe ein Objekt, req.session.userdas eine Instanz meiner Klasse ist User:

export class User {
    public login: string;
    public hashedPassword: string;

    constructor(login?: string, password?: string) {
        this.login = login || "" ;
        this.hashedPassword = password ? UserHelper.hashPassword(password) : "";
    }
}

Also habe ich meine own.d.tsDatei erstellt, um die Definition mit vorhandenen Express-Sitzungstypen zusammenzuführen:

import { User } from "./models/user";

declare module Express {
    export interface Session {
        user: User;
    }
}

Aber es funktioniert überhaupt nicht - VS Code und tsc sehen es nicht. Also habe ich eine Testdefinition mit einfachem Typ erstellt:

declare module Express {
    export interface Session {
        test: string;
    }
}

Und das Testfeld funktioniert in Ordnung, so dass der Import ein Problem verursacht.

Ich habe auch versucht, /// <reference path='models/user.ts'/>stattdessen Import hinzuzufügen, aber der tsc hat die Benutzerklasse nicht gesehen. Wie kann ich meine eigene Klasse in der Datei * d.ts verwenden?

BEARBEITEN : Ich habe tsc so eingestellt, dass beim Kompilieren Definitionsdateien generiert werden, und jetzt habe ich meine user.d.ts:

export declare class User {
    login: string;
    hashedPassword: string;
    constructor();
    constructor(login: string, password: string);
}

Und die eigene Typisierungsdatei zum Erweitern von Express Sesion:

import { User } from "./models/user";
declare module Express {
    export interface Session {
        user: User;
        uuid: string;
    }
}

Funktioniert aber immer noch nicht, wenn die Importanweisung oben steht. Irgendwelche Ideen?

Nach zwei Jahren TypeScript-Entwicklung habe ich es endlich geschafft, dieses Problem zu lösen.

Grundsätzlich gibt es in TypeScript zwei Arten von Deklarationen für Modultypen: "local" (normale Module) und ambient (global). Die zweite Art ermöglicht das Schreiben einer globalen Moduldeklaration, die mit der vorhandenen Moduldeklaration zusammengeführt wird. Was sind die Unterschiede zwischen diesen Dateien?

d.tsDateien werden nur dann als Umgebungsmoduldeklarationen behandelt, wenn sie keine Importe haben. Wenn Sie eine Importzeile angeben, wird diese jetzt als normale Moduldatei behandelt, nicht als globale, sodass das Erweitern der Moduldefinitionen nicht funktioniert.

Deshalb funktionieren alle hier diskutierten Lösungen nicht. Glücklicherweise können wir seit TS 2.9 Typen mithilfe der folgenden import()Syntax in die Deklaration globaler Module importieren :

declare namespace Express {
  interface Request {
    user: import("./user").User;
  }
}

Also macht die Linie import("./user").User;die Magie und jetzt funktioniert alles :)

AKTUALISIEREN

Seit Typoskript 2.9 scheinen Sie in der Lage zu sein, Typen in globale Module zu importieren. Weitere Informationen finden Sie in der akzeptierten Antwort.

URSPRÜNGLICHE ANTWORT

Ich denke, das Problem, mit dem Sie konfrontiert sind, besteht mehr darin, Moduldeklarationen zu erweitern als die Klassentypisierung.

Der Export ist in Ordnung, wie Sie feststellen werden, wenn Sie versuchen, dies zu kompilieren:

// app.ts  
import { User } from '../models/user'
let theUser = new User('theLogin', 'thePassword')

Es scheint, als ob Sie versuchen, die Moduldeklaration von zu erweitern Express, und Sie sind wirklich nah dran. Dies sollte den Trick tun:

// index.d.ts
import { User } from "./models/user";
declare module 'express' {
  interface Session {
    user: User;
    uuid: string;
  }
}

Die Richtigkeit dieses Codes hängt jedoch natürlich von der ursprünglichen Implementierung der Express-Deklarationsdatei ab.

Dank der Antwort von Michał Lytek . Hier ist eine andere Methode, die ich in meinem Projekt verwendet habe.

Wir können es mehrmals importieren Userund wiederverwenden , ohne import("./user").Userüberall schreiben zu müssen , und es sogar erweitern oder erneut exportieren .

declare namespace Express {
  import("./user");  // Don't delete this line.
  import { User } from "./user";

  export interface Request {
    user: User;
    target: User;
    friend: User;
  }

  export class SuperUser extends User {
    superPower: string;
  }

  export { User as ExpressUser }
}

Habe Spaß :)

Ist es nicht möglich, der Logik einfach zu folgen mit express-session:

own.d.ts::

import express = require('express');
import { User } from "../models/user";

declare global {
    namespace Express {
        interface Session {
            user: User;
            uuid: string;
        }
    }
}

In der Hauptsache index.ts:

import express from 'express';
import session from 'express-session';
import own from './types/own';

const app = express();
app.get('/', (req, res) => {
    let username = req!.session!.user.login;
});

Zumindest scheint dies ohne Probleme zu kompilieren. Den vollständigen Code finden Sie unter https://github.com/masa67/so39040108