mongoose - 从库中创建新类

Question

我不知道如何正确描述它，所以让我举个例子。我有一个库，它返回一个用作构造函数的函数:

var userTemplate = lib.User;
var user = new userTemplate();

我想将此 userTemplate 强类型化为一个类，因为我知道它将具有哪些属性。我还希望能够在应用程序的其他部分执行诸如 var user = new userTemplate() 之类的操作，并让 user 对象具有某种已知类型。

我觉得我需要在这里使用环境类声明，但我不确定如何将环境声明分配给实际构建器的引用？

例如，我想要这样的东西:

export class Storage{
    init(){

        // somehow define that when you 
        // new a User to call this function

        User = lib.User; 
     }
}

declare class User{
   public name:string;
}

基本上我想以某种方式定义声明实际用户的代码在哪里。根据我对环境声明的理解，它们是在“其他地方”指定的。我无法弄清楚这个“别处”到底在哪里。我检查了其中一个 typescript examples但我看不到 mongodb 环境声明是如何映射到实际实现的。

我觉得我在这里漏掉了一 block 拼图。

编辑(有细节)

让我在这里具体说明:

我正在尝试使用强类型 Mongoose 。假设我有一个架构类:

export class Schema{
    public UserData:User;

    constructor(){
        var mongoose:IMongooseBase = require("mongoose");
        var mongooseSchema = <MongooseSchema>mongoose.Schema;


        var user = new mongooseSchema({
            name: String
        });

        this.UserData = mongoose.model("User", user);
    }
}

export declare class User extends MongooseBase{
    constructor(item:any);
    public _id: string;
    public name: string;
}


declare class MongooseBase {
    findOne(item:any, callback:ICallback) : void;
    find(id:string, callback?:ICallback) : IChainable;
    save(item: IEmptyCallback) : void;
    remove(item:any, callback:IErrorCallback) : void;
    push(item:MongooseBase):void;
}

interface IMongooseSchema{
    ObjectId:String;
}

declare class MongooseSchema implements IMongooseSchema{
    constructor(item:any);
    public ObjectId:String;
}
interface IMongooseBase{
    model(name:String, ref:any):any;
    Schema():any;
}

Mongoose 的模型函数为我提供了一个用作构造函数的函数。使用此对象创建的任何新模型类型都将具有 MongooseBase 中定义的属性(例如 find、findOne 等)。我还希望此用户将用户属性定义为环境类 User(名称)中定义的架构的一部分。

因此，例如，在 javascript 中，这类似于

var userProxy = mongoose.Schema("User", user);

var userData = new userProxy();

用户对象包含从 mongoose 给你的任何东西继承的属性(我已经映射到 MongooseBase 定义)。它还为您提供作为初始模式创建的一部分传入的属性(当我定义 user 时)。

我希望能够强类型化这个代理，就像这样

var user:UserData = new schema.UserData();

如果我这样做， typescript 编译器会崩溃，并出现以下异常，让我相信我正在做一些疯狂古怪的事情，而且可能是不对的:

\AppData\Roaming\npm\node_modules\typescript\bin\tsc.js:24488
                throw err;
                      ^
TypeError: Cannot read property 'construct' of null
    at TypeFlow.typeCheckNew (\AppData\Roaming\npm\node_modules\typescript\bin\tsc.js:20675:27)
    at CallExpression.typeCheck (\AppData\Roaming\npm\node_modules\typescript\bin\tsc.js:1275:33)
    at TypeFlow.typeCheck (\AppData\Roaming\npm\node_modules\typescript\bin\tsc.js:18505:28)
    at TypeChecker.typeCheckWithContextualType (\AppData\Roaming\npm\node_modules\typescript\bin\tsc.js:15909:27)
    at TypeFlow.typeCheckBoundDecl (\AppData\Roaming\npm\node_modules\typescript\bin\tsc.js:18647:38)
    at VarDecl.BoundDecl.typeCheck (\AppData\Roaming\npm\node_modules\typescript\bin\tsc.js:1631:29)
    at ASTList.typeCheck (\AppData\Roaming\npm\node_modules\typescript\bin\tsc.js:1016:55)
    at TypeFlow.typeCheck (\AppData\Roaming\npm\node_modules\typescript\bin\tsc.js:18505:28)
    at TypeFlow.typeCheckFunction (\AppData\Roaming\npm\node_modules\typescript\bin\tsc.js:19815:22)
    at FuncDecl.typeCheck (\AppData\Roaming\npm\node_modules\typescript\bin\tsc.js:1783:29)

编辑2

所以我设置它的方式在 webstorm 中没有出现任何错误，并且为其他文件生成的代码确实可以正常工作(它与我自己编写的 javascript 匹配)，但是 typescript 编译器崩溃并且不会更新我使用引用的文件。

Answer 1

看起来您想在其中声明您的库和构造函数(建模为下面的类)。这是您要找的吗？

declare module lib {
  export class User {
    name: string;
    age: number;
    getChildren(): User[];
  }
}

var userTemplate = lib.User;
var user = new userTemplate();
user.name = "dave";

通常，您的库声明将位于您引用的 .d.ts 文件中。

如果我正确理解了您的问题，请告诉我。

进一步信息后编辑

好的。我不熟悉 Mongoose，但让我看看我是否理解正确(在快速查看 http://mongoosejs.com/docs/index.html 之后)

• 您有一个由属性包定义的模式，其中键是名称，值是类型，即 { name: String, age: Number}。
• 您将其传递给 mongoose.Schema，它会返回一个新文档“schema”。
• 您将其传递给 mongoose.model(连同名称)并为与该模式匹配的新“文档”取回一个构造函数
• 然后您可以通过概述的架构构造函数“新建”文档。
• 返回的对象还具有常见的 mongoose 文档方法，例如用于数据存储操作的“保存”和“查找”。

这很有趣，因为 Schema 归结为结构类型大纲，类似于 TypeScript 中的接口(interface)，以几乎类似于 JSON 的语法指定，传递原始构造函数以指定类型(数字、字符串、日期等... ).但是，由于 TypeScript 类型是纯粹的注释，在发出的 JavaScript 中不存在，因此您不能重用它们(并且它们具有不同的类型，例如 ObjectID)。

一旦我们在语言中获得了泛型，我们就有了更聪明的方法来做到这一点，并通过查找、保存等来处理文档类型……但下面是我目前能想到的最简单的输入方法。这更符合你所追求的吗？

// Let's type it as any for now
declare var mongoose: any;

// Base interface that any 'document' will have
interface mongooseBase {
    find: (callback: { (err: any, items: any[]): void; }) => void;
    save: (hanlder: { (err: any): void; }) => void;
}

// This is the structure our 'person' document will have
interface person extends mongooseBase {
    name: string;
    age: number;
    children: { name: string; dependent: bool; }[];
};

// Need to provide the same structure in 'mongoose' style format to define.
var personSchema = mongoose.Schema({ name: String, age: Number, children: [{ name: String, dependent: Boolean }] });

// Get back a constructor function.  We assert that the type returned is a 'newable' Function (a constructor), and will return a 'person' type when called
var Person = <{ new (): person; }>mongoose.model('Person', personSchema);

// Let's create one
var p1 = new Person();

// Let's set a property
p1.name = "Dave";

// Let's save Dave
p1.save(function (err) { /*TODO*/ });