Example: Quick Start

import { Binary, createConnection, Document, Field, Index, ObjectId } from "ts-mongodb-orm";

@Index({numberValue: -1})
@Document({collectionName: "CustomCollectionName"}) // default to Class name
class QuickStart {
@Field()
public _id!: ObjectId;

@Field()
public stringValue?: string;

@Field()
public numberValue: number = 0;

@Field()
public booleanValue: boolean = false;

@Field({index: -1})
public dateValue: Date = new Date();

@Field()
public arrayValue: number[] = [1, 2, 3];

@Field()
public objectArrayValue: any = {};

@Field()
public binary: Binary = new Binary(Buffer.alloc(0));
}

async function quickStartExample() {
const connection = await createConnection({
uri: "mongodb+srv://USERNAME:PASSWORD@xxxxxxx.gcp.mongodb.net",
dbName: "DbName",
mongoClientOptions: {
w: "majority",
ignoreUndefined: true, // preventing saving null value in server side
serverSelectionTimeoutMS: 5000,
},
});

// operations
const repository = connection.getRepository(QuickStart);
await repository.createCollection({strict: true}); // throw error if collection already exist
await repository.syncIndex();
await repository.dropCollection();

// documents operations
const document1 = new QuickStart();
document1.stringValue = "hello world 1";
document1.numberValue = 999;

await repository.insert(document1);
await repository.update(document1);
await repository.delete(document1);

// query
const findDocument1 = await repository.findOne(document1._id);
const findDocument2 = await repository.query().filter("_id", document1._id).findOne();
const aggregate1 = await repository.aggregate().count("numberValue").findOne();

// transaction
const transactionManager = connection.getTransactionManager();
await transactionManager.startTransaction(async (session) => {
const document2 = repository.create({stringValue: "hello world 2"});
await repository.insert(document2, {session});
});

// async iterator
const iterator = await repository.query().filter("numberValue", 1).getAsyncIterator();
for await (const document1 of iterator) {
// handle document
}

// delete many by condition
const query2 = repository.query();
const deletedTotal = await query2
.filter("numberValue", 1)
.getDeleter()
.deleteMany();

// update many by condition
const query3 = repository.query();
const updatedTotal = await query3
.filter("numberValue", 1)
.getUpdater()
.inc("numberValue", 10)
.updateMany();

for await (const item of iterator) {
}

// find total
const result1 = await repository.aggregate()
.match(x => x.filter("numberValue", 1))
.count("total")
.findOne();

// skip
const results2 = await repository.aggregate()
.sort({index: 1})
.skip(5)
.limit(10)
.findMany();

// some field you may want weakType
const result3 = await repository.aggregate({weakType: true})
.match(x => x.filter("anyFieldName", 1))
.findOne();

// cast to document directly
const result4 = await repository.aggregate()
.toDocument()
.findOne();
const {stringValue} = result4!;
}

try {
const result = await transactionManager1.startTransaction(async (session) => {
const document1 = new QuickStart();
await repository.insert(document1, {session});

const foundDocument1 = await repository.findOne(document1._id, {session});
const foundDocument2 = await repository.query({session})
.filter("_id", document1._id)
.findOne();

// we can abort transaction
if (1 < 2) {
await session.abortTransaction();
}

return [1, 2, 3];
});

@Field()
public uniqueField?: string;

@Field()
public dateField?: Date;

@Field()
public filterField?: string;

@Field()
public textField?: string;

@Field()
public numberValue?: number;
}

const repository1 = connection.getRepository(IndexDocument);

// syncIndexes will drop non exist index and then new a new one
// this will also create collection if not exist
await repository1.syncIndex();

// addIndexes will only try to new new one
// this will also create collection if not exist
await repository1.addIndex();

// drop all index
await repository1.dropIndex();

stream.on("insert", next => {
const {document, documentKey, operationType} = next;
});

stream.on("update", next => {
});

stream.on("delete", next => {
});

stream.on("change", next => {
// any type of operations includes insert, update, delete, replace, drop, dropDatabase, rename, invalidate
});

stream.on("end", () => {
// steam is ended
});

stream.on("close", () => {
// steam is closed
});
}

@AfterLoad()
public afterLoad() {
// this won't await for promise
}

@BeforeUpsert()
@BeforeInsert()
@BeforeUpdate()
@BeforeDelete()
public before(type: string) { // type: afterLoad, upsert, insert, update, delete
// this won't await for promise
}
}

@Field({isRequired: true, schema: {bsonType: "string"}})
public stringField?: string;

@Field({isRequired: true, schema: {bsonType: "date"}})
public dateField?: Date;

@Field({isRequired: true, schema: {type: "number", minimum: 10, exclusiveMinimum: true}})
public numberField?: number;

@Field({schema: {bsonType: "object", additionalProperties: true, properties: {name: {bsonType: "string"}}}})
public objectField?: any;
}

const repository1 = connection.getRepository(SchemaValidationDocument);

// this will also create collection with validation
await repository1.createCollection();

// or you can sync the validation later on (this need admin right)
await repository1.syncSchemaValidation();

// view existing validation
const options = await repository1.getCollection().options();

try {
const document1 = repository1.create();
await repository1.insert(document1);
} catch (err) {
// err.message === "Document failed validation"
}
}

const document1 = new QuickStart();
await repository.insert(document1);
await repository.delete(document1);

try {
await repository.update(document1);
} catch (err) {
if (err instanceof TsMongodbOrmError) {
// error managed by this library

} else if (err instanceof MongoError) {
// error from the native mongodb library

} else {
// other error

@Document()
class BufferDocument {
@Field()
public _id!: ObjectId;

@Field()
public buffer: Buffer = Buffer.alloc(0);

@Field()
public bufferObject?: {buffer: Buffer};
}

const repository = connection.getRepository(BufferDocument);
const document = await repository.create({buffer: Buffer.alloc(10)});
await repository.insert(document);