From 84c014076249c34ee059564662386c311b264eef Mon Sep 17 00:00:00 2001 From: Bret Little Date: Fri, 1 Feb 2013 15:22:03 -0700 Subject: [PATCH 1/4] Initial mongoose def commit --- mongoose/mongoose-test.ts | 32 ++++++++ mongoose/mongoose.d.ts | 165 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 197 insertions(+) create mode 100644 mongoose/mongoose-test.ts create mode 100644 mongoose/mongoose.d.ts diff --git a/mongoose/mongoose-test.ts b/mongoose/mongoose-test.ts new file mode 100644 index 0000000000..e3bb1a82e3 --- /dev/null +++ b/mongoose/mongoose-test.ts @@ -0,0 +1,32 @@ +/// + +import mongoose = module("mongoose"); + +var mongoose2 = mongoose.Mongoose(); + +mongoose.connect('localhost', 'test').disconnect(()=>{}); +mongoose.disconnect(); + +mongoose.set("key", "value").set("key", "value"); +mongoose.get("key"); + +mongoose.model("model"); +//@todo add tests for other model creation signatures + +mongoose.plugin(()=>{}).plugin(()=>{}, {}); +mongoose.exports.get("key"); + +//Connection Interface +var conn = new mongoose.Connection(mongoose2); +conn.open("test").open("test2", "db", 3, {}, ()=>{}); +conn.openSet("test").openSet("test2", "db", {t: 3}, ()=>{}); +conn.close().close(()=>{}); +conn.collection("test"); +conn.collection("test", {}); +conn.model("test"); +conn.setProfiling("0", 50); +conn.db; +conn.collections.test; +conn.readyState; + + diff --git a/mongoose/mongoose.d.ts b/mongoose/mongoose.d.ts new file mode 100644 index 0000000000..46c4531234 --- /dev/null +++ b/mongoose/mongoose.d.ts @@ -0,0 +1,165 @@ +interface MongooseInstance { + new(): MongooseInstance; + set(key: string, value: string) : MongooseInstance; + get(key: string) : string; + createConnection(uri?: string, options?: any) : MongooseInstance; + connect(...args: any[]) : MongooseInstance; + disconnect(fn?: Function) : MongooseInstance; + model(name: string, schema?: Schema, collection?: string, skipInit?: bool): Model; + plugin(fn: Function, opts?: any): MongooseInstance; + exports: MongooseInstance; + Collection: Collection; + Connection: Connection; + version() : string; +} + +interface Query { + +} + +interface findAndModifyOptions { + sort: bool; + select: bool; +} + +interface findAndUpdateOptions extends findAndModifyOptions { + new: bool; + upsert: bool; +} + +interface updateOptions { + safe: bool; + upsert: bool; + multi: bool; +} + +interface Model { + new(doc: any): Model; + save(fn?: Function): void; + increment(): Model; + remove(fn?: Function): Document; + model(name: string) : Model; + $where(argument: any): Query; + ensureIndexes(cb?: Function): void; + remove(conditions: Object, callback?: Function): Query; + find(conditions: Object, fields?: Object, options?: Object, callback?: Function): Query; + findById(id: any, fields?: Object, options?: Object, callback?: Function): Query; + findOne(conditions: Object, fields?: Object, options?: Object, callback?: Function): Query; + count(conditions: Object, callback?: Function): Query; + distinct(field: string, conditions?: Object, callback?: Function): Query; + where(path: string, val?: Object): Query; + findOneAndUpdate(conditions?: Object, update?: Object, options?: findAndUpdateOptions, callback?: Function): Query; + findByIdAndUpdate(id: any, update?: Object, options?: findAndUpdateOptions, callback?: Function): Query; + findOneAndRemove(conditions: Object, options?: findAndModifyOptions, callback?: Function): Query; + findByIdAndRemove(id: any, options?: findAndModifyOptions, callback?: Function): Query; + create(doc: any, callback: Function); + update(conditions: Object, update: Object, options?: updateOptions, callback?: Function): Query; + mapReduce(o: Object, callback: Function); + aggregate(array: Array, options?: Object, callback?: Function); + base: MongooseInstance; + schema: Schema; + modelName: string; + collection: Collection; + db: any; +} + +interface DocumentToObjectSettings { + getters ?: bool; + virtuals ?: bool; + minimize ?: bool; + transform ?: Function ; +} + +interface Document { + new(): Document; + update(doc: Object, options: Object, callback: Function); + set(path: any, val: any, type?: any, options?: Object): Document; + get(path: string, type: any): any; + markModified(path: string): void; + modifiedPaths(): Array; + isModified(path?: string): bool; + isDirectModified(path: string): bool; + isInit(path: string) :bool; + isSelected(path: string): bool; + validate(db: Function): Document; + invalidate(path: string, err: any): void; + toObject(options?: DocumentToObjectSettings): any; + toJSON(options) : any; + inspect(options?: any); + toString(); + equals(doc: Document): bool; + errors: Object; + id: string; + isNew: bool; + schema: Schema; +} + +interface Schema { + Types: { + String: any; + Number: any; + Boolean: any; + Bool: any; + Array: any; + Buffer: any; + Date: any; + ObjectId: any; + Oid: any; + Mixed: any; + }; +} + +interface Promise { + new(back: Function): Promise; + on(event: string, callback: Function): Promise; + complete(); + error(): Promise; + addCallback(fn: Function): Promise; + addErrback(fn: Function): Promise; + addBack(fn: Function): Promise; + resolve(err?: any, val?: Object); +} + +interface SchemaType { + +} + +interface Collection { + +} + +interface Connection { + new(base: MongooseInstance) : Connection; + open(connection_string: string, database?: string, port?: number, options?: Object, callback?: Function): Connection; + openSet(urlis: string, database?: string, options?: Object, callback?: Function): Connection; + close(callback?:Function): Connection; + collection(name: string, options?: Object): Collection; + model(name: string, schema?: Schema, collection?: Collection): Model; + setProfiling(level: any, ms?: number, callback?: Function): void; + db: any; + collections: any; + readyState: number; +} + + +interface CheerioStatic { +// (...selectors: any[]): Cheerio; +// (): Cheerio; +} + +declare module "mongoose" { + export function Mongoose(): MongooseInstance; + export function set(key: string, value: string) : MongooseInstance; + export function get(key: string) : string; + export function createConnection(uri?: string, options?: any): MongooseInstance; + export function connect(...args: any[]): MongooseInstance; + export function disconnect(fn?: Function): MongooseInstance; + export function model(name: string, schema?: Schema, collection?: string, skipInit?: bool): Model; + export function plugin(fn: Function, opts?: any): MongooseInstance; + export var exports : MongooseInstance; + export var Collection : Collection; + export var Connection : Connection; + export function version() : string; + export var Schema : Schema; + export var SchemaType: SchemaType; +} From 8ebf0010ca52ae8aac0f5b8ccd66f41e7beb2821 Mon Sep 17 00:00:00 2001 From: Bret Little Date: Fri, 1 Feb 2013 16:29:00 -0700 Subject: [PATCH 2/4] Add the mongoose api for Query, Promise, and QueryStream --- mongoose/mongoose-test.ts | 41 ++++++++++++++ mongoose/mongoose.d.ts | 115 +++++++++++++++++++++++++++++++++----- 2 files changed, 143 insertions(+), 13 deletions(-) diff --git a/mongoose/mongoose-test.ts b/mongoose/mongoose-test.ts index e3bb1a82e3..24a0172b43 100644 --- a/mongoose/mongoose-test.ts +++ b/mongoose/mongoose-test.ts @@ -29,4 +29,45 @@ conn.db; conn.collections.test; conn.readyState; +//Document Interface +//Model Interface +var model = mongoose.model("model"); +model.save().save(()=>{}); +model.increment().increment(); +model.remove().remove(()=>{}); +model.model("test").save(); +model.$where('this.comments.length > 5'); +model.$where(()=>{}); +model.ensureIndexes(); +model.ensureIndexes(()=>{}); +model.remove({title: ""}); +model.remove({title: ""}, ()=>{}); +model.find({ name: 'john', age: { $gte: 18 }}); +model.find({ name: /john/i }, null, { skip: 10 }, function (err, docs) {}); +model.findById("", 'name', { lean: true }, function (err, doc) {}); +model.findById("", function (err, adventure) {}); +model.findOne({ type: 'iphone' }, 'name', { lean: true }, ()=>{}); +model.count({ type: 'jungle' }, function (err, count) {}); +model.count({ type: 'test'}); +model.distinct("test"); +model.distinct("test", {}, ()=>{}); +model.where('test'); +model.where('test', {}); +model.findOneAndUpdate({ name: 'test'}, { name: 'jason borne' }, {}, ()=>{}); +model.findByIdAndUpdate("", { name: 'jason borne' }, {}, ()=>{}); +model.findOneAndRemove({val: "test"}); +model.findOneAndRemove({val: "tst"}, {}, ()=>{}); +model.findByIdAndRemove(""); +model.findByIdAndRemove("", {}, ()=>{}); +model.create({ type: 'test' }, { type: 'test2' }, ()=>{}); +model.create([{ type: 'test' }, { type: 'test2' }], ()=>{}); +model.update({test: "test"}, {test: "tst2"}); +model.update({test: "test"}, {test: "tst2"}, {safe: true, upsert: false}, ()=>{}); +model.mapReduce({}, ()=>{}); +model.aggregate([]); +model.aggregate([], {}, ()=>{}); +model.base.get("key"); +model.schema; +model.collection; +model.db; diff --git a/mongoose/mongoose.d.ts b/mongoose/mongoose.d.ts index 46c4531234..39c7a256b5 100644 --- a/mongoose/mongoose.d.ts +++ b/mongoose/mongoose.d.ts @@ -13,33 +13,121 @@ interface MongooseInstance { version() : string; } -interface Query { - +interface QueryOptions { + tailable?: any; + sort?: any; + limit?: any; + skip?: any; + maxscan?: any; + batchSize?: any; + comment?: any; + snapshot?: any; + hint?: any; + slaveOk?: any; + lean?: any; + safe?: any; } +interface Query { + new(criteria: Object, options?: Object): Query; + setOptions(options: QueryOptions): Query; + exec(operation?: String, callback?: Function): Promise; + exec(operation?: Function, callback?: Function): Promise; + find(criteria?: Object, callback?: Function): Query; + cast(model: Model, obj?: Object): Object; + $where(js: string): Query; + $where(js: Function): Query; + where(path?: string, val?: Object): Query; + equals(val: Object): Query; + or(array: Array): Query; + nor(array: Array): Query; + and(array: Array): Query; + gt(path: string, val: number): Query; + gte(path: string, val: number): Query; + lt(path: string, val: number): Query; + lte(path: string, val: number): Query; + ne(path: string, val: number): Query; + in(path: string, val: number): Query; + nin(path: string, val: number): Query; + all(path: string, val: number): Query; + size(path: string, val: number): Query; + regex(path: string, val: number): Query; + maxDistance(path: string, val: number): Query; + near(path: string, val: number): Query; + nearSphere(path: string, val: Object): Query; + mod(path: string, val: number): Query; + exists(path: string, val: number): Query; + elemMatch(path: any, val: any): Query; + box(path: string, val: Object): Query; + center(path: string, val: Object, opts?: Object): Query; + centerSphere(path: string, val: Object): Query; + polygon(path: string, val: Array): Query; + polygon(path: string, val: Object): Query; + select(arg: Object): Query; + select(arg: string): Query; + slice(path: string, val: number): Query; + sort(arg: Object): Query; + sort(arg: String): Query; + limit(val: number): Query; + skip(val: number): Query; + maxscan(val: number): Query; + batchSize(val: number): Query; + comment(val: number): Query; + snapShot(): Query; + hint(val: Object): Query; + slaveOk(v: bool): Query; + read(pref: string, tags?: Array): Query; + lean(v: bool): Query; + tailable(v: bool): Query; + findOne(callback: Function): Query; + count(callback: Function): Query; + distinct( field: string, callback: Function): Query; + update(doc: Object, callback: Function): Query; + remove(callback: Function): Query; + findOneAndUpdate(query?: Object, doc?: Object, options?: findAndUpdateOptions, callback?: Function): Query; + findOneAndRemove(conditions?: Object, options?: findAndModifyOptions, callback?: Function): Query; + populate(path: string, fields?: Object, model?: Model, conditions?: Object, options?: Object): Query; + populate(path: string, fields?: string, model?: Model, conditions?: Object, options?: Object): Query; + stream(): QueryStream; + within: Query; +} + + +interface QueryStream { + new(query: Query): QueryStream; + pause(); + resume(); + destroy(err: any); + pipe(); + paused: bool; + readable: bool; +} + + interface findAndModifyOptions { - sort: bool; - select: bool; + sort?: bool; + select?: bool; } interface findAndUpdateOptions extends findAndModifyOptions { - new: bool; - upsert: bool; + new?: bool; + upsert?: bool; } interface updateOptions { - safe: bool; - upsert: bool; - multi: bool; + safe?: bool; + upsert?: bool; + multi?: bool; } interface Model { new(doc: any): Model; - save(fn?: Function): void; + save(fn?: Function); increment(): Model; - remove(fn?: Function): Document; + remove(fn?: Function): Model; model(name: string) : Model; - $where(argument: any): Query; + $where(argument: string): Query; + $where(argument: Function): Query; ensureIndexes(cb?: Function): void; remove(conditions: Object, callback?: Function): Query; find(conditions: Object, fields?: Object, options?: Object, callback?: Function): Query; @@ -52,7 +140,8 @@ interface Model { findByIdAndUpdate(id: any, update?: Object, options?: findAndUpdateOptions, callback?: Function): Query; findOneAndRemove(conditions: Object, options?: findAndModifyOptions, callback?: Function): Query; findByIdAndRemove(id: any, options?: findAndModifyOptions, callback?: Function): Query; - create(doc: any, callback: Function); + create(doc: Array, callback: Function); + create(...args: any[]); update(conditions: Object, update: Object, options?: updateOptions, callback?: Function): Query; mapReduce(o: Object, callback: Function); aggregate(array: Array, options?: Object, callback?: Function); From 204569719e06f6cc5b9cf3780d06f7fd919ade06 Mon Sep 17 00:00:00 2001 From: Bret Little Date: Tue, 12 Feb 2013 22:08:16 -0700 Subject: [PATCH 3/4] Add restify definition --- restify/restify-test.ts | 17 +++++++++++++++++ restify/restify.d.ts | 40 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 57 insertions(+) create mode 100644 restify/restify-test.ts create mode 100644 restify/restify.d.ts diff --git a/restify/restify-test.ts b/restify/restify-test.ts new file mode 100644 index 0000000000..57510df970 --- /dev/null +++ b/restify/restify-test.ts @@ -0,0 +1,17 @@ +/// + +import restify = module("restify"); + +var server = restify.createServer({ + formatters: { + 'application/foo': function formatFoo(req, res, body) { + if (body instanceof Error) + return body.stack; + + if (body) + return body.toString('base64'); + + return body; + } + } +}); diff --git a/restify/restify.d.ts b/restify/restify.d.ts new file mode 100644 index 0000000000..ae4b7429b9 --- /dev/null +++ b/restify/restify.d.ts @@ -0,0 +1,40 @@ +interface Server { + use: (... handler: any[]) => any; + post: (route: any, routeCallBack: (req: any, res: any, next: any) => any) => any; + put: (route: any, routeCallBack: (req: any, res: any, next: any) => any) => any; + del: (route: any, routeCallBack: (req: any, res: any, next: any) => any) => any; + get: (route: any, routeCallBack: (req: any, res: any, next: any) => any) => any; + head: (route: any, routeCallBack: (req: any, res: any, next: any) => any) => any; +} + +interface ServerOptions { + certificate ?: string; + key ?: string; + formatters ?: Object; + log ?: Object; + name ?: string; + spdy ?: Object; + version ?: string; + responseTimerHeader ?: string; + responseTimeFormatter ?: (durationInMilliseconds: number) => any; +} + +declare module "restify" { + export function createServer(options: ServerOptions): Server; + export class ConflictError { new(message: any): ConflictError; }; + export class InvalidArguementError { new(message: any): InvalidArguementError; }; + export class RestError { new(message: any): RestError; }; + export class BadDigestError { new(message: any): BadDigestError; }; + export class BadMethodError { new(message: any): BadMethodError; }; + export class InternalError { new(message: any): InternalError; }; + export class InvalidContentError { new(message: any): InvalidContentError; }; + export class InvalidCredentialsError { new(message: any): InvalidCredentialsError; }; + export class InvalidHeaderError { new(message: any): InvalidHeaderError; }; + export class InvalidVersionError { new(message: any): InvalidVersionError; }; + export class MissingParameterError { new(message: any): MissingParameterError; }; + export class NotAuthorizedError { new(message: any): NotAuthorizedError; }; + export class RequestExpiredError { new(message: any): RequestExpiredError; }; + export class RequestThrottledError { new(message: any): RequestThrottledError; }; + export class ResourceNotFoundError { new(message: any): ResourceNotFoundError; }; + export class WrongAcceptError { new(message: any): WrongAcceptError; }; +} From baa2dc5651a55e0da0ae5bbe94295415b57eb82f Mon Sep 17 00:00:00 2001 From: Bret Little Date: Thu, 14 Feb 2013 13:46:32 -0700 Subject: [PATCH 4/4] Finish restify typescript definition including its server and client api --- mongoose/mongoose-test.ts | 73 ----------- mongoose/mongoose.d.ts | 254 -------------------------------------- restify/restify-test.ts | 201 ++++++++++++++++++++++++++++++ restify/restify.d.ts | 160 ++++++++++++++++++++---- 4 files changed, 337 insertions(+), 351 deletions(-) delete mode 100644 mongoose/mongoose-test.ts delete mode 100644 mongoose/mongoose.d.ts diff --git a/mongoose/mongoose-test.ts b/mongoose/mongoose-test.ts deleted file mode 100644 index 24a0172b43..0000000000 --- a/mongoose/mongoose-test.ts +++ /dev/null @@ -1,73 +0,0 @@ -/// - -import mongoose = module("mongoose"); - -var mongoose2 = mongoose.Mongoose(); - -mongoose.connect('localhost', 'test').disconnect(()=>{}); -mongoose.disconnect(); - -mongoose.set("key", "value").set("key", "value"); -mongoose.get("key"); - -mongoose.model("model"); -//@todo add tests for other model creation signatures - -mongoose.plugin(()=>{}).plugin(()=>{}, {}); -mongoose.exports.get("key"); - -//Connection Interface -var conn = new mongoose.Connection(mongoose2); -conn.open("test").open("test2", "db", 3, {}, ()=>{}); -conn.openSet("test").openSet("test2", "db", {t: 3}, ()=>{}); -conn.close().close(()=>{}); -conn.collection("test"); -conn.collection("test", {}); -conn.model("test"); -conn.setProfiling("0", 50); -conn.db; -conn.collections.test; -conn.readyState; - -//Document Interface - -//Model Interface -var model = mongoose.model("model"); -model.save().save(()=>{}); -model.increment().increment(); -model.remove().remove(()=>{}); -model.model("test").save(); -model.$where('this.comments.length > 5'); -model.$where(()=>{}); -model.ensureIndexes(); -model.ensureIndexes(()=>{}); -model.remove({title: ""}); -model.remove({title: ""}, ()=>{}); -model.find({ name: 'john', age: { $gte: 18 }}); -model.find({ name: /john/i }, null, { skip: 10 }, function (err, docs) {}); -model.findById("", 'name', { lean: true }, function (err, doc) {}); -model.findById("", function (err, adventure) {}); -model.findOne({ type: 'iphone' }, 'name', { lean: true }, ()=>{}); -model.count({ type: 'jungle' }, function (err, count) {}); -model.count({ type: 'test'}); -model.distinct("test"); -model.distinct("test", {}, ()=>{}); -model.where('test'); -model.where('test', {}); -model.findOneAndUpdate({ name: 'test'}, { name: 'jason borne' }, {}, ()=>{}); -model.findByIdAndUpdate("", { name: 'jason borne' }, {}, ()=>{}); -model.findOneAndRemove({val: "test"}); -model.findOneAndRemove({val: "tst"}, {}, ()=>{}); -model.findByIdAndRemove(""); -model.findByIdAndRemove("", {}, ()=>{}); -model.create({ type: 'test' }, { type: 'test2' }, ()=>{}); -model.create([{ type: 'test' }, { type: 'test2' }], ()=>{}); -model.update({test: "test"}, {test: "tst2"}); -model.update({test: "test"}, {test: "tst2"}, {safe: true, upsert: false}, ()=>{}); -model.mapReduce({}, ()=>{}); -model.aggregate([]); -model.aggregate([], {}, ()=>{}); -model.base.get("key"); -model.schema; -model.collection; -model.db; diff --git a/mongoose/mongoose.d.ts b/mongoose/mongoose.d.ts deleted file mode 100644 index 39c7a256b5..0000000000 --- a/mongoose/mongoose.d.ts +++ /dev/null @@ -1,254 +0,0 @@ -interface MongooseInstance { - new(): MongooseInstance; - set(key: string, value: string) : MongooseInstance; - get(key: string) : string; - createConnection(uri?: string, options?: any) : MongooseInstance; - connect(...args: any[]) : MongooseInstance; - disconnect(fn?: Function) : MongooseInstance; - model(name: string, schema?: Schema, collection?: string, skipInit?: bool): Model; - plugin(fn: Function, opts?: any): MongooseInstance; - exports: MongooseInstance; - Collection: Collection; - Connection: Connection; - version() : string; -} - -interface QueryOptions { - tailable?: any; - sort?: any; - limit?: any; - skip?: any; - maxscan?: any; - batchSize?: any; - comment?: any; - snapshot?: any; - hint?: any; - slaveOk?: any; - lean?: any; - safe?: any; -} - -interface Query { - new(criteria: Object, options?: Object): Query; - setOptions(options: QueryOptions): Query; - exec(operation?: String, callback?: Function): Promise; - exec(operation?: Function, callback?: Function): Promise; - find(criteria?: Object, callback?: Function): Query; - cast(model: Model, obj?: Object): Object; - $where(js: string): Query; - $where(js: Function): Query; - where(path?: string, val?: Object): Query; - equals(val: Object): Query; - or(array: Array): Query; - nor(array: Array): Query; - and(array: Array): Query; - gt(path: string, val: number): Query; - gte(path: string, val: number): Query; - lt(path: string, val: number): Query; - lte(path: string, val: number): Query; - ne(path: string, val: number): Query; - in(path: string, val: number): Query; - nin(path: string, val: number): Query; - all(path: string, val: number): Query; - size(path: string, val: number): Query; - regex(path: string, val: number): Query; - maxDistance(path: string, val: number): Query; - near(path: string, val: number): Query; - nearSphere(path: string, val: Object): Query; - mod(path: string, val: number): Query; - exists(path: string, val: number): Query; - elemMatch(path: any, val: any): Query; - box(path: string, val: Object): Query; - center(path: string, val: Object, opts?: Object): Query; - centerSphere(path: string, val: Object): Query; - polygon(path: string, val: Array): Query; - polygon(path: string, val: Object): Query; - select(arg: Object): Query; - select(arg: string): Query; - slice(path: string, val: number): Query; - sort(arg: Object): Query; - sort(arg: String): Query; - limit(val: number): Query; - skip(val: number): Query; - maxscan(val: number): Query; - batchSize(val: number): Query; - comment(val: number): Query; - snapShot(): Query; - hint(val: Object): Query; - slaveOk(v: bool): Query; - read(pref: string, tags?: Array): Query; - lean(v: bool): Query; - tailable(v: bool): Query; - findOne(callback: Function): Query; - count(callback: Function): Query; - distinct( field: string, callback: Function): Query; - update(doc: Object, callback: Function): Query; - remove(callback: Function): Query; - findOneAndUpdate(query?: Object, doc?: Object, options?: findAndUpdateOptions, callback?: Function): Query; - findOneAndRemove(conditions?: Object, options?: findAndModifyOptions, callback?: Function): Query; - populate(path: string, fields?: Object, model?: Model, conditions?: Object, options?: Object): Query; - populate(path: string, fields?: string, model?: Model, conditions?: Object, options?: Object): Query; - stream(): QueryStream; - within: Query; -} - - -interface QueryStream { - new(query: Query): QueryStream; - pause(); - resume(); - destroy(err: any); - pipe(); - paused: bool; - readable: bool; -} - - -interface findAndModifyOptions { - sort?: bool; - select?: bool; -} - -interface findAndUpdateOptions extends findAndModifyOptions { - new?: bool; - upsert?: bool; -} - -interface updateOptions { - safe?: bool; - upsert?: bool; - multi?: bool; -} - -interface Model { - new(doc: any): Model; - save(fn?: Function); - increment(): Model; - remove(fn?: Function): Model; - model(name: string) : Model; - $where(argument: string): Query; - $where(argument: Function): Query; - ensureIndexes(cb?: Function): void; - remove(conditions: Object, callback?: Function): Query; - find(conditions: Object, fields?: Object, options?: Object, callback?: Function): Query; - findById(id: any, fields?: Object, options?: Object, callback?: Function): Query; - findOne(conditions: Object, fields?: Object, options?: Object, callback?: Function): Query; - count(conditions: Object, callback?: Function): Query; - distinct(field: string, conditions?: Object, callback?: Function): Query; - where(path: string, val?: Object): Query; - findOneAndUpdate(conditions?: Object, update?: Object, options?: findAndUpdateOptions, callback?: Function): Query; - findByIdAndUpdate(id: any, update?: Object, options?: findAndUpdateOptions, callback?: Function): Query; - findOneAndRemove(conditions: Object, options?: findAndModifyOptions, callback?: Function): Query; - findByIdAndRemove(id: any, options?: findAndModifyOptions, callback?: Function): Query; - create(doc: Array, callback: Function); - create(...args: any[]); - update(conditions: Object, update: Object, options?: updateOptions, callback?: Function): Query; - mapReduce(o: Object, callback: Function); - aggregate(array: Array, options?: Object, callback?: Function); - base: MongooseInstance; - schema: Schema; - modelName: string; - collection: Collection; - db: any; -} - -interface DocumentToObjectSettings { - getters ?: bool; - virtuals ?: bool; - minimize ?: bool; - transform ?: Function ; -} - -interface Document { - new(): Document; - update(doc: Object, options: Object, callback: Function); - set(path: any, val: any, type?: any, options?: Object): Document; - get(path: string, type: any): any; - markModified(path: string): void; - modifiedPaths(): Array; - isModified(path?: string): bool; - isDirectModified(path: string): bool; - isInit(path: string) :bool; - isSelected(path: string): bool; - validate(db: Function): Document; - invalidate(path: string, err: any): void; - toObject(options?: DocumentToObjectSettings): any; - toJSON(options) : any; - inspect(options?: any); - toString(); - equals(doc: Document): bool; - errors: Object; - id: string; - isNew: bool; - schema: Schema; -} - -interface Schema { - Types: { - String: any; - Number: any; - Boolean: any; - Bool: any; - Array: any; - Buffer: any; - Date: any; - ObjectId: any; - Oid: any; - Mixed: any; - }; -} - -interface Promise { - new(back: Function): Promise; - on(event: string, callback: Function): Promise; - complete(); - error(): Promise; - addCallback(fn: Function): Promise; - addErrback(fn: Function): Promise; - addBack(fn: Function): Promise; - resolve(err?: any, val?: Object); -} - -interface SchemaType { - -} - -interface Collection { - -} - -interface Connection { - new(base: MongooseInstance) : Connection; - open(connection_string: string, database?: string, port?: number, options?: Object, callback?: Function): Connection; - openSet(urlis: string, database?: string, options?: Object, callback?: Function): Connection; - close(callback?:Function): Connection; - collection(name: string, options?: Object): Collection; - model(name: string, schema?: Schema, collection?: Collection): Model; - setProfiling(level: any, ms?: number, callback?: Function): void; - db: any; - collections: any; - readyState: number; -} - - -interface CheerioStatic { -// (...selectors: any[]): Cheerio; -// (): Cheerio; -} - -declare module "mongoose" { - export function Mongoose(): MongooseInstance; - export function set(key: string, value: string) : MongooseInstance; - export function get(key: string) : string; - export function createConnection(uri?: string, options?: any): MongooseInstance; - export function connect(...args: any[]): MongooseInstance; - export function disconnect(fn?: Function): MongooseInstance; - export function model(name: string, schema?: Schema, collection?: string, skipInit?: bool): Model; - export function plugin(fn: Function, opts?: any): MongooseInstance; - export var exports : MongooseInstance; - export var Collection : Collection; - export var Connection : Connection; - export function version() : string; - export var Schema : Schema; - export var SchemaType: SchemaType; -} diff --git a/restify/restify-test.ts b/restify/restify-test.ts index 57510df970..964a428b5c 100644 --- a/restify/restify-test.ts +++ b/restify/restify-test.ts @@ -15,3 +15,204 @@ var server = restify.createServer({ } } }); + +server = restify.createServer({ + certificate: "test", + key: "test", + formatters: {}, + log: {}, + name: "test", + spdy: {}, + version: "", + responseTimeHeader: "", + responseTimeFormatter : (durationInMilliseconds: number) => {} +}); + +server.on('someEvent', ()=>{}); + + +server.use((req, res, next)=>{}); +server.use([(req, res, next)=>{}]); +server.use((req, res, next)=>{}, (req, res, next)=>{}); + +function send(req, res, next) { + req.header('key', 'val'); + req.header('key') === 'val'; + + req.accepts('test') === true; + req.is('test') === true; + + req.getLogger('test'); + + var log = req.log; + log.debug({params: req.params}, 'Hello there %s', 'foo'); + + req.contentLength === 50; + req.contentType === 'test'; + req.href === 'test'; + req.id === 'test'; + req.path === 'test'; + req.query === 'test'; + req.secure === true; + req.time === 50; + req.params; + + res.header('test'); + res.header('test', {}); + res.header('test', new Date()); + + res.cache(); + res.cache('testst', {}); + + res.status(344); + + res.send({hello: 'world'}); + res.send(201, {hello: 'world'}); + res.send(new restify.BadRequestError('meh')); + + res.json(201, {hello: 'world'}); + res.json({hello: 'world'}); + + res.code === 50; + res.contentLength === 50; + res.charSet === 'test'; + res.contentType === 'test'; + res.headers; + res.id === 'test'; + + res.send('hello ' + req.params.name); + return next(); +} + + +server.post('/hello', send); +server.put( '/hello', send); +server.del( '/hello', send); +server.get( '/hello', send); +server.head('/hello', send); + +server.post(/(.*)/, send); +server.put( /(.*)/, send); +server.del( /(.*)/, send); +server.get( /(.*)/, send); +server.head(/(.*)/, send); + +new restify.ConflictError("test"); +new restify.InvalidArguementError("message"); +new restify.RestError("message"); +new restify.BadDigestError("message"); +new restify.BadMethodError("message"); +new restify.BadRequestError('test'); +new restify.InternalError("message"); +new restify.InvalidContentError("message"); +new restify.InvalidCredentialsError("message"); +new restify.InvalidHeaderError("message"); +new restify.InvalidVersionError("message"); +new restify.MissingParameterError("message"); +new restify.NotAuthorizedError("message"); +new restify.RequestExpiredError("jjmessage"); +new restify.RequestThrottledError("message"); +new restify.ResourceNotFoundError("message"); +new restify.WrongAcceptError("message"); + +server.name = ""; +server.version = ""; +server.log = {}; +server.acceptable = ["test"]; +server.url = ""; + +server.address().port; +server.address().family; +server.address().address; + +server.listen("somePath", send); +server.close(); + +server.use(restify.acceptParser(server.acceptable)); +server.use(restify.authorizationParser()); +server.use(restify.dateParser()); +server.use(restify.queryParser()); +server.use(restify.jsonp()); +server.use(restify.gzipResponse()); +server.use(restify.bodyParser()); +server.use(restify.throttle({ + burst: 100, + rate: 50, + ip: true, + overrides: { + '192.168.1.1': { + rate: 0, + burst: 0 + } + } +})); + +server.on('after', restify.auditLogger({ + log: ()=>{} +})); + +restify.defaultResponseHeaders = function(data) { + this.header('Server', 'helloworld'); +}; + +restify.defaultResponseHeaders = false; + +//RESTIFY Client Tests + +var client = restify.createJsonClient({ + url: 'https://api.us-west-1.joyentcloud.com', + version: '*' +}); + +client = restify.createStringClient({ + accept: "test", + connectTimeout: 30, + dtrace: {}, + gzip: {}, + headers: {}, + log: {}, + retry: {}, + signRequest: ()=>{}, + url: "", + userAgent: "", + version: "" +}); + +client.get("test", send); +client.head('test', send); +client.post('path', {}, send); +client.put('path', {}, send); +client.del('path', send); + +client.post('/foo', { hello: 'world' }, function(err, req, res, obj) { + console.log('%d -> %j', res.statusCode, res.headers); + console.log('%j', obj); +}); + +client.get('/foo/bar', function(err, req, res, data) { + console.log('%s', data); +}); + +var client2 = restify.createClient({ + url: 'http://127.0.0.1' +}); + +client2.get('/str/mcavage', function(err, req) { + + req.on('result', function(err, res) { + + res.body = ''; + res.setEncoding('utf8'); + res.on('data', function(chunk) { + res.body += chunk; + }); + + res.on('end', function() { + console.log(res.body); + }); + }); +}); + + +client.basicAuth('test', 'password'); +client2.basicAuth('test', 'password'); diff --git a/restify/restify.d.ts b/restify/restify.d.ts index ae4b7429b9..9d5edd93d9 100644 --- a/restify/restify.d.ts +++ b/restify/restify.d.ts @@ -1,10 +1,59 @@ +interface addressInterface { + port: number; + family: string; + address: string; +} + +interface Request { + header: (key: string, defaultValue?: string) => any; + accepts: (type: string) => bool; + is: (type: string) => bool; + getLogger: (component: string) => any; + contentLength: number; + contentType: string; + href: string; + log: Object; + id: string; + path: string; + query: string; + secure: bool; + time: number; + params: any; +} + +interface Response { + header: (key: string, value ?: any) => any; + cache: (type?: any, options?: Object) => any; + status: (code: number) => any; + send: (status?: any, body?: any) => any; + json: (status?: any, body?: any) => any; + code: number; + contentLength: number; + charSet: string; + contentType: string; + headers: Object; + statusCode: number; + id: string; +} + interface Server { use: (... handler: any[]) => any; - post: (route: any, routeCallBack: (req: any, res: any, next: any) => any) => any; - put: (route: any, routeCallBack: (req: any, res: any, next: any) => any) => any; - del: (route: any, routeCallBack: (req: any, res: any, next: any) => any) => any; - get: (route: any, routeCallBack: (req: any, res: any, next: any) => any) => any; - head: (route: any, routeCallBack: (req: any, res: any, next: any) => any) => any; + post: (route: any, routeCallBack: (req: Request, res: Response, next: Function) => any) => any; + put: (route: any, routeCallBack: (req: Request, res: Response, next: Function) => any) => any; + del: (route: any, routeCallBack: (req: Request, res: Response, next: Function) => any) => any; + get: (route: any, routeCallBack: (req: Request, res: Response, next: Function ) => any) => any; + head: (route: any, routeCallBack: (req: Request, res: Response, next: Function) => any) => any; + on: (event: string, callback: Function) => any; + name: string; + version: string; + log: Object; + acceptable: string[]; + url: string; + address: () => addressInterface; + listen: (... args: any[]) => any; + close: (... args: any[]) => any; + pre: (routeCallBack: (req: Request, res: Response, next: Function) => any) => any; + } interface ServerOptions { @@ -15,26 +64,89 @@ interface ServerOptions { name ?: string; spdy ?: Object; version ?: string; - responseTimerHeader ?: string; + responseTimeHeader ?: string; responseTimeFormatter ?: (durationInMilliseconds: number) => any; } -declare module "restify" { - export function createServer(options: ServerOptions): Server; - export class ConflictError { new(message: any): ConflictError; }; - export class InvalidArguementError { new(message: any): InvalidArguementError; }; - export class RestError { new(message: any): RestError; }; - export class BadDigestError { new(message: any): BadDigestError; }; - export class BadMethodError { new(message: any): BadMethodError; }; - export class InternalError { new(message: any): InternalError; }; - export class InvalidContentError { new(message: any): InvalidContentError; }; - export class InvalidCredentialsError { new(message: any): InvalidCredentialsError; }; - export class InvalidHeaderError { new(message: any): InvalidHeaderError; }; - export class InvalidVersionError { new(message: any): InvalidVersionError; }; - export class MissingParameterError { new(message: any): MissingParameterError; }; - export class NotAuthorizedError { new(message: any): NotAuthorizedError; }; - export class RequestExpiredError { new(message: any): RequestExpiredError; }; - export class RequestThrottledError { new(message: any): RequestThrottledError; }; - export class ResourceNotFoundError { new(message: any): ResourceNotFoundError; }; - export class WrongAcceptError { new(message: any): WrongAcceptError; }; +interface ClientOptions { + accept?: string; + connectTimeout?: number; + dtrace?: Object; + gzip?: Object; + headers?: Object; + log?: Object; + retry?: Object; + signRequest?: Function; + url?: string; + userAgent?: string; + version?: string; +} + +interface Client { + get: (path: string, callback?: (err: any, req: Request, res: Response, obj: any) => any) => any; + head: (path: string, callback?: (err: any, req: Request, res: Response) => any) => any; + post: (path: string, object: any, callback?: (err: any, req: Request, res: Response, obj: any) => any) => any; + put: (path: string, object: any, callback?: (err: any, req: Request, res: Response, obj: any) => any) => any; + del: (path: string, callback?: (err: any, req: Request, res: Response) => any) => any; + basicAuth: (username: string, password: string) => any; +} + +interface HttpClient extends Client { + get: (path?: any, callback?: Function) => any; + head: (path?:any, callback?: Function) => any; + post: (opts?: any, callback?: Function) => any; + put: (opts?: any, callback?: Function) => any; + del: (opts?: any, callback?: Function) => any; +} + +interface ThrottleOptions { + burst?: number; + rate?: number; + ip?: bool; + xff?: bool; + username?: bool; + tokensTable?: Object; + maxKeys?: number; + overrides?: Object; +} + +declare module "restify" { + export function createServer(options?: ServerOptions): Server; + + export function createJsonClient(options?: ClientOptions): Client; + export function createStringClient(options?: ClientOptions): Client; + export function createClient(options?: ClientOptions): HttpClient; + + export class ConflictError { constructor(message?: any); }; + export class InvalidArguementError { constructor(message?: any); }; + export class RestError { constructor(message?: any); }; + export class BadDigestError { constructor(message: any); }; + export class BadMethodError { constructor(message: any); }; + export class BadRequestError { constructor(message: any); }; + export class InternalError { constructor(message: any); }; + export class InvalidContentError { constructor(message: any); }; + export class InvalidCredentialsError { constructor(message: any); }; + export class InvalidHeaderError { constructor(message: any); }; + export class InvalidVersionError { constructor(message: any); }; + export class MissingParameterError { constructor(message: any); }; + export class NotAuthorizedError { constructor(message: any); }; + export class RequestExpiredError { constructor(message: any); }; + export class RequestThrottledError { constructor(message: any); }; + export class ResourceNotFoundError { constructor(message: any); }; + export class WrongAcceptError { constructor(message: any); }; + + export function acceptParser(parser: any); + export function authorizationParser(); + export function dateParser(skew?: number); + export function queryParser(options?: Object); + export function urlEncodedBodyParser(options?: Object); + export function jsonp(options?: Object); + export function gzipResponse(options?: Object); + export function bodyParser(options?: Object); + export function requestLogger(options?: Object); + export function serveStatic(options?: Object); + export function throttle(options?: ThrottleOptions); + export function conditionalRequest(options?: Object); + export function auditLogger(options?: Object); + export var defaultResponseHeaders : any; }