|
|
@@ -0,0 +1,2391 @@
|
|
|
+import {format} from 'util';
|
|
|
+import {expect} from 'chai';
|
|
|
+import {ObjectId} from 'mongodb';
|
|
|
+import {MongoClient} from 'mongodb';
|
|
|
+import {Schema} from '@e22m4u/repository';
|
|
|
+import {Service} from '@e22m4u/repository';
|
|
|
+import {DataType} from '@e22m4u/repository';
|
|
|
+import {createMongodbUrl} from './utils/index.js';
|
|
|
+import {MongodbAdapter} from './mongodb-adapter.js';
|
|
|
+import {AdapterRegistry} from '@e22m4u/repository';
|
|
|
+import {DEFAULT_PRIMARY_KEY_PROPERTY_NAME as DEF_PK} from '@e22m4u/repository';
|
|
|
+
|
|
|
+const CONFIG = {
|
|
|
+ host: process.env.MONGODB_HOST || 'localhost',
|
|
|
+ port: process.env.MONGODB_PORT || 27017,
|
|
|
+ database: process.env.MONGODB_DATABASE,
|
|
|
+};
|
|
|
+
|
|
|
+const MDB_CLIENT = new MongoClient(createMongodbUrl(CONFIG));
|
|
|
+const ADAPTERS_STACK = [];
|
|
|
+
|
|
|
+function createSchema() {
|
|
|
+ const schema = new Schema();
|
|
|
+ const adapter = new MongodbAdapter(schema._services, CONFIG);
|
|
|
+ ADAPTERS_STACK.push(adapter);
|
|
|
+ schema.defineDatasource({name: 'mongodb', adapter: 'mongodb'});
|
|
|
+ schema.get(AdapterRegistry)._adapters['mongodb'] = adapter;
|
|
|
+ return schema;
|
|
|
+}
|
|
|
+
|
|
|
+describe('MongodbAdapter', function () {
|
|
|
+ this.timeout(15000);
|
|
|
+
|
|
|
+ afterEach(async function () {
|
|
|
+ await MDB_CLIENT.db(CONFIG.database).dropDatabase();
|
|
|
+ });
|
|
|
+
|
|
|
+ after(async function () {
|
|
|
+ for await (const adapter of ADAPTERS_STACK) {
|
|
|
+ await adapter.disconnect();
|
|
|
+ }
|
|
|
+ await MDB_CLIENT.close(true);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('able to connect and disconnect', async function () {
|
|
|
+ const S = new Service();
|
|
|
+ const adapter = new MongodbAdapter(S._services, CONFIG);
|
|
|
+ await adapter.connect();
|
|
|
+ expect(adapter.connected).to.be.true;
|
|
|
+ await adapter.disconnect();
|
|
|
+ });
|
|
|
+
|
|
|
+ describe('create', function () {
|
|
|
+ it('generates a new identifier when a value of a primary key is not provided', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const result = await rep.create({foo: 'bar'});
|
|
|
+ expect(result).to.be.eql({[DEF_PK]: result[DEF_PK], foo: 'bar'});
|
|
|
+ expect(typeof result[DEF_PK]).to.be.eq('string');
|
|
|
+ expect(result[DEF_PK]).to.have.lengthOf(24);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('generates a new identifier when a value of a primary key is undefined', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const result = await rep.create({[DEF_PK]: undefined, foo: 'bar'});
|
|
|
+ expect(result).to.be.eql({[DEF_PK]: result[DEF_PK], foo: 'bar'});
|
|
|
+ expect(typeof result[DEF_PK]).to.be.eq('string');
|
|
|
+ expect(result[DEF_PK]).to.have.lengthOf(24);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('generates a new identifier when a value of a primary key is null', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const result = await rep.create({[DEF_PK]: null, foo: 'bar'});
|
|
|
+ expect(result).to.be.eql({[DEF_PK]: result[DEF_PK], foo: 'bar'});
|
|
|
+ expect(typeof result[DEF_PK]).to.be.eq('string');
|
|
|
+ expect(result[DEF_PK]).to.have.lengthOf(24);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('generates a new identifier for a primary key of a "string" type', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({
|
|
|
+ name: 'model',
|
|
|
+ datasource: 'mongodb',
|
|
|
+ properties: {
|
|
|
+ id: {
|
|
|
+ type: DataType.STRING,
|
|
|
+ primaryKey: true,
|
|
|
+ },
|
|
|
+ },
|
|
|
+ });
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const result = await rep.create({[DEF_PK]: null, foo: 'bar'});
|
|
|
+ expect(result).to.be.eql({[DEF_PK]: result[DEF_PK], foo: 'bar'});
|
|
|
+ expect(typeof result[DEF_PK]).to.be.eq('string');
|
|
|
+ expect(result[DEF_PK]).to.have.lengthOf(24);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('generates a new identifier for a primary key of a "any" type', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({
|
|
|
+ name: 'model',
|
|
|
+ datasource: 'mongodb',
|
|
|
+ properties: {
|
|
|
+ id: {
|
|
|
+ type: DataType.ANY,
|
|
|
+ primaryKey: true,
|
|
|
+ },
|
|
|
+ },
|
|
|
+ });
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const result = await rep.create({[DEF_PK]: null, foo: 'bar'});
|
|
|
+ expect(result).to.be.eql({[DEF_PK]: result[DEF_PK], foo: 'bar'});
|
|
|
+ expect(typeof result[DEF_PK]).to.be.eq('string');
|
|
|
+ expect(result[DEF_PK]).to.have.lengthOf(24);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('throws an error when generating a new value for a primary key of a "number" type', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({
|
|
|
+ name: 'model',
|
|
|
+ datasource: 'mongodb',
|
|
|
+ properties: {
|
|
|
+ id: {
|
|
|
+ type: DataType.NUMBER,
|
|
|
+ primaryKey: true,
|
|
|
+ },
|
|
|
+ },
|
|
|
+ });
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const promise = rep.create({});
|
|
|
+ expect(promise).to.be.rejectedWith(
|
|
|
+ 'MongoDB unable to generate primary keys of Number. ' +
|
|
|
+ 'Do provide your own value for the "id" property ' +
|
|
|
+ 'or set the property type to String.',
|
|
|
+ );
|
|
|
+ });
|
|
|
+
|
|
|
+ it('throws an error when generating a new value for a primary key of a "boolean" type', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({
|
|
|
+ name: 'model',
|
|
|
+ datasource: 'mongodb',
|
|
|
+ properties: {
|
|
|
+ id: {
|
|
|
+ type: DataType.BOOLEAN,
|
|
|
+ primaryKey: true,
|
|
|
+ },
|
|
|
+ },
|
|
|
+ });
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const promise = rep.create({});
|
|
|
+ expect(promise).to.be.rejectedWith(
|
|
|
+ 'MongoDB unable to generate primary keys of Boolean. ' +
|
|
|
+ 'Do provide your own value for the "id" property ' +
|
|
|
+ 'or set the property type to String.',
|
|
|
+ );
|
|
|
+ });
|
|
|
+
|
|
|
+ it('throws an error when generating a new value for a primary key of a "array" type', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({
|
|
|
+ name: 'model',
|
|
|
+ datasource: 'mongodb',
|
|
|
+ properties: {
|
|
|
+ id: {
|
|
|
+ type: DataType.ARRAY,
|
|
|
+ primaryKey: true,
|
|
|
+ },
|
|
|
+ },
|
|
|
+ });
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const promise = rep.create({});
|
|
|
+ expect(promise).to.be.rejectedWith(
|
|
|
+ 'MongoDB unable to generate primary keys of Array. ' +
|
|
|
+ 'Do provide your own value for the "id" property ' +
|
|
|
+ 'or set the property type to String.',
|
|
|
+ );
|
|
|
+ });
|
|
|
+
|
|
|
+ it('throws an error when generating a new value for a primary key of a "object" type', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({
|
|
|
+ name: 'model',
|
|
|
+ datasource: 'mongodb',
|
|
|
+ properties: {
|
|
|
+ id: {
|
|
|
+ type: DataType.OBJECT,
|
|
|
+ primaryKey: true,
|
|
|
+ },
|
|
|
+ },
|
|
|
+ });
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const promise = rep.create({});
|
|
|
+ expect(promise).to.be.rejectedWith(
|
|
|
+ 'MongoDB unable to generate primary keys of Object. ' +
|
|
|
+ 'Do provide your own value for the "id" property ' +
|
|
|
+ 'or set the property type to String.',
|
|
|
+ );
|
|
|
+ });
|
|
|
+
|
|
|
+ it('allows to specify an ObjectID instance for a default primary key', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const oid = new ObjectId();
|
|
|
+ const result = await rep.create({[DEF_PK]: oid});
|
|
|
+ expect(result).to.be.eql({[DEF_PK]: String(oid)});
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.not.null;
|
|
|
+ });
|
|
|
+
|
|
|
+ it('allows to specify an ObjectID string for a default primary key', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const oid = new ObjectId();
|
|
|
+ const id = String(oid);
|
|
|
+ const result = await rep.create({[DEF_PK]: id});
|
|
|
+ expect(result).to.be.eql({[DEF_PK]: id});
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.not.null;
|
|
|
+ });
|
|
|
+
|
|
|
+ it('allows to specify an ObjectID instance for "id" primary key', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({
|
|
|
+ name: 'model',
|
|
|
+ datasource: 'mongodb',
|
|
|
+ properties: {
|
|
|
+ id: {
|
|
|
+ type: DataType.ANY,
|
|
|
+ primaryKey: true,
|
|
|
+ },
|
|
|
+ },
|
|
|
+ });
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const oid = new ObjectId();
|
|
|
+ const result = await rep.create({id: oid});
|
|
|
+ expect(result).to.be.eql({id: String(oid)});
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.not.null;
|
|
|
+ });
|
|
|
+
|
|
|
+ it('allows to specify an ObjectID string for "id" primary key', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({
|
|
|
+ name: 'model',
|
|
|
+ datasource: 'mongodb',
|
|
|
+ properties: {
|
|
|
+ id: {
|
|
|
+ type: DataType.STRING,
|
|
|
+ primaryKey: true,
|
|
|
+ },
|
|
|
+ },
|
|
|
+ });
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const oid = new ObjectId();
|
|
|
+ const id = String(oid);
|
|
|
+ const result = await rep.create({id});
|
|
|
+ expect(result).to.be.eql({id});
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.not.null;
|
|
|
+ });
|
|
|
+
|
|
|
+ it('allows to specify an ObjectID instance for "_id" primary key', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({
|
|
|
+ name: 'model',
|
|
|
+ datasource: 'mongodb',
|
|
|
+ properties: {
|
|
|
+ _id: {
|
|
|
+ type: DataType.ANY,
|
|
|
+ primaryKey: true,
|
|
|
+ },
|
|
|
+ },
|
|
|
+ });
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const oid = new ObjectId();
|
|
|
+ const result = await rep.create({_id: oid});
|
|
|
+ expect(result).to.be.eql({_id: String(oid)});
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.not.null;
|
|
|
+ });
|
|
|
+
|
|
|
+ it('allows to specify an ObjectID string for "_id" primary key', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({
|
|
|
+ name: 'model',
|
|
|
+ datasource: 'mongodb',
|
|
|
+ properties: {
|
|
|
+ _id: {
|
|
|
+ type: DataType.STRING,
|
|
|
+ primaryKey: true,
|
|
|
+ },
|
|
|
+ },
|
|
|
+ });
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const oid = new ObjectId();
|
|
|
+ const id = String(oid);
|
|
|
+ const result = await rep.create({_id: id});
|
|
|
+ expect(result).to.be.eql({_id: id});
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.not.null;
|
|
|
+ });
|
|
|
+
|
|
|
+ it('throws an error for a custom primary key', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({
|
|
|
+ name: 'model',
|
|
|
+ datasource: 'mongodb',
|
|
|
+ properties: {
|
|
|
+ myId: {
|
|
|
+ type: DataType.ANY,
|
|
|
+ primaryKey: true,
|
|
|
+ },
|
|
|
+ },
|
|
|
+ });
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const oid = new ObjectId();
|
|
|
+ const promise = rep.create({myId: oid});
|
|
|
+ await expect(promise).to.be.rejectedWith(
|
|
|
+ 'MongoDB is not supporting custom names of the primary key. ' +
|
|
|
+ 'Do use "id" as a primary key instead of "myId".',
|
|
|
+ );
|
|
|
+ });
|
|
|
+
|
|
|
+ it('throws an error if a given "number" identifier already exists', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ await rep.create({[DEF_PK]: 10});
|
|
|
+ const promise = rep.create({[DEF_PK]: 10});
|
|
|
+ await expect(promise).to.be.rejectedWith(
|
|
|
+ 'E11000 duplicate key error collection: test.model index: ' +
|
|
|
+ '_id_ dup key: { _id: 10 }',
|
|
|
+ );
|
|
|
+ });
|
|
|
+
|
|
|
+ it('throws an error if a given "string" identifier already exists', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ await rep.create({[DEF_PK]: 'str'});
|
|
|
+ const promise = rep.create({[DEF_PK]: 'str'});
|
|
|
+ await expect(promise).to.be.rejectedWith(
|
|
|
+ 'E11000 duplicate key error collection: test.model index: ' +
|
|
|
+ '_id_ dup key: { _id: "str" }',
|
|
|
+ );
|
|
|
+ });
|
|
|
+
|
|
|
+ it('throws an error if a given ObjectId instance identifier already exists', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const oid = new ObjectId();
|
|
|
+ await rep.create({[DEF_PK]: oid});
|
|
|
+ const promise = rep.create({[DEF_PK]: oid});
|
|
|
+ await expect(promise).to.be.rejectedWith(
|
|
|
+ format(
|
|
|
+ 'E11000 duplicate key error collection: test.model index: ' +
|
|
|
+ "_id_ dup key: { _id: ObjectId('%s') }",
|
|
|
+ oid,
|
|
|
+ ),
|
|
|
+ );
|
|
|
+ });
|
|
|
+
|
|
|
+ it('throws an error if a given ObjectId string identifier already exists', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const oid = new ObjectId();
|
|
|
+ const id = String(oid);
|
|
|
+ await rep.create({[DEF_PK]: id});
|
|
|
+ const promise = rep.create({[DEF_PK]: id});
|
|
|
+ await expect(promise).to.be.rejectedWith(
|
|
|
+ format(
|
|
|
+ 'E11000 duplicate key error collection: test.model index: ' +
|
|
|
+ "_id_ dup key: { _id: ObjectId('%s') }",
|
|
|
+ id,
|
|
|
+ ),
|
|
|
+ );
|
|
|
+ });
|
|
|
+
|
|
|
+ it('uses a specified column name for a regular property', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({
|
|
|
+ name: 'model',
|
|
|
+ datasource: 'mongodb',
|
|
|
+ properties: {
|
|
|
+ foo: {
|
|
|
+ type: DataType.NUMBER,
|
|
|
+ columnName: 'bar',
|
|
|
+ },
|
|
|
+ },
|
|
|
+ });
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const result = await rep.create({foo: 10});
|
|
|
+ expect(result).to.be.eql({[DEF_PK]: result[DEF_PK], foo: 10});
|
|
|
+ const oid = new ObjectId(result[DEF_PK]);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.eql({_id: oid, bar: 10});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('uses a specified column name for a regular property with a default value', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({
|
|
|
+ name: 'model',
|
|
|
+ datasource: 'mongodb',
|
|
|
+ properties: {
|
|
|
+ foo: {
|
|
|
+ type: DataType.NUMBER,
|
|
|
+ columnName: 'bar',
|
|
|
+ default: 10,
|
|
|
+ },
|
|
|
+ },
|
|
|
+ });
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const result = await rep.create({});
|
|
|
+ expect(result).to.be.eql({[DEF_PK]: result[DEF_PK], foo: 10});
|
|
|
+ const oid = new ObjectId(result[DEF_PK]);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.eql({_id: oid, bar: 10});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('stores a Date instance as date and returns string type', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const date = new Date();
|
|
|
+ const dateString = date.toISOString();
|
|
|
+ const result = await rep.create({date});
|
|
|
+ expect(result).to.be.eql({[DEF_PK]: result[DEF_PK], date: dateString});
|
|
|
+ const oid = new ObjectId(result[DEF_PK]);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.eql({_id: oid, date});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('stores a Date string as date and returns string type', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const date = new Date();
|
|
|
+ const dateString = date.toISOString();
|
|
|
+ const result = await rep.create({date: dateString});
|
|
|
+ expect(result).to.be.eql({[DEF_PK]: result[DEF_PK], date: dateString});
|
|
|
+ const oid = new ObjectId(result[DEF_PK]);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.eql({_id: oid, date});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('stores a string as is', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const result = await rep.create({foo: 'str'});
|
|
|
+ expect(result).to.be.eql({[DEF_PK]: result[DEF_PK], foo: 'str'});
|
|
|
+ const oid = new ObjectId(result[DEF_PK]);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.eql({_id: oid, foo: 'str'});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('stores a number as is', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const result = await rep.create({foo: 10});
|
|
|
+ expect(result).to.be.eql({[DEF_PK]: result[DEF_PK], foo: 10});
|
|
|
+ const oid = new ObjectId(result[DEF_PK]);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.eql({_id: oid, foo: 10});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('stores a boolean as is', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const result = await rep.create({foo: true, bar: false});
|
|
|
+ expect(result).to.be.eql({
|
|
|
+ [DEF_PK]: result[DEF_PK],
|
|
|
+ foo: true,
|
|
|
+ bar: false,
|
|
|
+ });
|
|
|
+ const oid = new ObjectId(result[DEF_PK]);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.eql({_id: oid, foo: true, bar: false});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('stores an array as is', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const result = await rep.create({foo: ['bar']});
|
|
|
+ expect(result).to.be.eql({
|
|
|
+ [DEF_PK]: result[DEF_PK],
|
|
|
+ foo: ['bar'],
|
|
|
+ });
|
|
|
+ const oid = new ObjectId(result[DEF_PK]);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.eql({_id: oid, foo: ['bar']});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('stores an object as is', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const result = await rep.create({foo: {bar: 10}});
|
|
|
+ expect(result).to.be.eql({
|
|
|
+ [DEF_PK]: result[DEF_PK],
|
|
|
+ foo: {bar: 10},
|
|
|
+ });
|
|
|
+ const oid = new ObjectId(result[DEF_PK]);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.eql({_id: oid, foo: {bar: 10}});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('stores an undefined as null', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const result = await rep.create({foo: undefined});
|
|
|
+ expect(result).to.be.eql({
|
|
|
+ [DEF_PK]: result[DEF_PK],
|
|
|
+ foo: null,
|
|
|
+ });
|
|
|
+ const oid = new ObjectId(result[DEF_PK]);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.eql({_id: oid, foo: null});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('stores an null as is', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const result = await rep.create({foo: null});
|
|
|
+ expect(result).to.be.eql({
|
|
|
+ [DEF_PK]: result[DEF_PK],
|
|
|
+ foo: null,
|
|
|
+ });
|
|
|
+ const oid = new ObjectId(result[DEF_PK]);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.eql({_id: oid, foo: null});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('uses a short fields clause to filter results', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const result = await rep.create({foo: 10, bar: 20}, {fields: 'foo'});
|
|
|
+ expect(result).to.be.eql({[DEF_PK]: result[DEF_PK], foo: 10});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('uses a full fields clause to filter results', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const result = await rep.create(
|
|
|
+ {foo: 10, bar: 20, baz: 30},
|
|
|
+ {fields: ['foo', 'bar']},
|
|
|
+ );
|
|
|
+ expect(result).to.be.eql({[DEF_PK]: result[DEF_PK], foo: 10, bar: 20});
|
|
|
+ const oid = new ObjectId(result[DEF_PK]);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.eql({_id: oid, foo: 10, bar: 20, baz: 30});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('a fields clause uses property names instead of column names', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({
|
|
|
+ name: 'model',
|
|
|
+ datasource: 'mongodb',
|
|
|
+ properties: {
|
|
|
+ foo: {
|
|
|
+ type: DataType.NUMBER,
|
|
|
+ columnName: 'fooCol',
|
|
|
+ },
|
|
|
+ bar: {
|
|
|
+ type: DataType.NUMBER,
|
|
|
+ columnName: 'barCol',
|
|
|
+ },
|
|
|
+ baz: {
|
|
|
+ type: DataType.NUMBER,
|
|
|
+ columnName: 'bazCol',
|
|
|
+ },
|
|
|
+ },
|
|
|
+ });
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const result = await rep.create(
|
|
|
+ {foo: 10, bar: 20, baz: 30},
|
|
|
+ {fields: ['fooCol', 'barCol']},
|
|
|
+ );
|
|
|
+ expect(result).to.be.eql({[DEF_PK]: result[DEF_PK]});
|
|
|
+ });
|
|
|
+ });
|
|
|
+
|
|
|
+ describe('replaceById', function () {
|
|
|
+ it('removes properties when replacing an item by a given identifier', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created = await rep.create({foo: 10});
|
|
|
+ const id = created[DEF_PK];
|
|
|
+ const replaced = await rep.replaceById(id, {bar: 20});
|
|
|
+ expect(replaced).to.be.eql({[DEF_PK]: id, bar: 20});
|
|
|
+ const oid = new ObjectId(id);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.eql({_id: oid, bar: 20});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ignores identifier value in a given data in case of a default primary key', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ await rep.create({[DEF_PK]: 'foo', prop: 10});
|
|
|
+ const replaced = await rep.replaceById('foo', {
|
|
|
+ [DEF_PK]: 'bar',
|
|
|
+ prop: 20,
|
|
|
+ });
|
|
|
+ expect(replaced).to.be.eql({[DEF_PK]: 'foo', prop: 20});
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: 'foo'});
|
|
|
+ expect(rawData).to.be.eql({_id: 'foo', prop: 20});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ignores identifier value in a given data in case of a custom primary key', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({
|
|
|
+ name: 'model',
|
|
|
+ datasource: 'mongodb',
|
|
|
+ properties: {
|
|
|
+ myId: {
|
|
|
+ type: DataType.STRING,
|
|
|
+ primaryKey: true,
|
|
|
+ columnName: '_id',
|
|
|
+ },
|
|
|
+ },
|
|
|
+ });
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ await rep.create({myId: 'foo', prop: 10});
|
|
|
+ const replaced = await rep.replaceById('foo', {myId: 'bar', prop: 20});
|
|
|
+ expect(replaced).to.be.eql({myId: 'foo', prop: 20});
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: 'foo'});
|
|
|
+ expect(rawData).to.be.eql({_id: 'foo', prop: 20});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('throws an error if a given identifier does not exist', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const oid = new ObjectId();
|
|
|
+ const promise = rep.replaceById(oid, {foo: 10});
|
|
|
+ await expect(promise).to.be.rejectedWith(
|
|
|
+ format('Identifier "%s" is not found.', oid),
|
|
|
+ );
|
|
|
+ });
|
|
|
+
|
|
|
+ it('throws an error for a custom primary key', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({
|
|
|
+ name: 'model',
|
|
|
+ datasource: 'mongodb',
|
|
|
+ properties: {
|
|
|
+ myId: {
|
|
|
+ type: DataType.ANY,
|
|
|
+ primaryKey: true,
|
|
|
+ },
|
|
|
+ },
|
|
|
+ });
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const promise = rep.replaceById('id', {foo: 10});
|
|
|
+ await expect(promise).to.be.rejectedWith(
|
|
|
+ 'MongoDB is not supporting custom names of the primary key. ' +
|
|
|
+ 'Do use "id" as a primary key instead of "myId".',
|
|
|
+ );
|
|
|
+ });
|
|
|
+
|
|
|
+ it('uses a specified column name for a regular property', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({
|
|
|
+ name: 'model',
|
|
|
+ datasource: 'mongodb',
|
|
|
+ properties: {
|
|
|
+ foo: {
|
|
|
+ type: DataType.NUMBER,
|
|
|
+ columnName: 'bar',
|
|
|
+ },
|
|
|
+ },
|
|
|
+ });
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created = await rep.create({foo: 10});
|
|
|
+ const id = created[DEF_PK];
|
|
|
+ const replaced = await rep.replaceById(id, {foo: 20});
|
|
|
+ expect(replaced).to.be.eql({[DEF_PK]: id, foo: 20});
|
|
|
+ const oid = new ObjectId(id);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.eql({_id: oid, bar: 20});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('stores a Date instance as date and returns string type', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const date = new Date();
|
|
|
+ const dateString = date.toISOString();
|
|
|
+ const created = await rep.create({date: null});
|
|
|
+ const id = created[DEF_PK];
|
|
|
+ const replaced = await rep.replaceById(id, {date});
|
|
|
+ expect(replaced).to.be.eql({[DEF_PK]: id, date: dateString});
|
|
|
+ const oid = new ObjectId(id);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.eql({_id: oid, date});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('stores a Date string as date and returns string type', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const date = new Date();
|
|
|
+ const dateString = date.toISOString();
|
|
|
+ const created = await rep.create({date: null});
|
|
|
+ const id = created[DEF_PK];
|
|
|
+ const replaced = await rep.replaceById(id, {date: dateString});
|
|
|
+ expect(replaced).to.be.eql({[DEF_PK]: id, date: dateString});
|
|
|
+ const oid = new ObjectId(id);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.eql({_id: oid, date});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('stores a string as is', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created = await rep.create({foo: null});
|
|
|
+ const id = created[DEF_PK];
|
|
|
+ const replaced = await rep.replaceById(id, {foo: 'str'});
|
|
|
+ expect(replaced).to.be.eql({[DEF_PK]: id, foo: 'str'});
|
|
|
+ const oid = new ObjectId(id);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.eql({_id: oid, foo: 'str'});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('stores a number as is', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created = await rep.create({foo: null});
|
|
|
+ const id = created[DEF_PK];
|
|
|
+ const replaced = await rep.replaceById(id, {foo: 10});
|
|
|
+ expect(replaced).to.be.eql({[DEF_PK]: id, foo: 10});
|
|
|
+ const oid = new ObjectId(id);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.eql({_id: oid, foo: 10});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('stores a boolean as is', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created = await rep.create({foo: null, bar: null});
|
|
|
+ const id = created[DEF_PK];
|
|
|
+ const replaced = await rep.replaceById(id, {foo: true, bar: false});
|
|
|
+ expect(replaced).to.be.eql({[DEF_PK]: id, foo: true, bar: false});
|
|
|
+ const oid = new ObjectId(id);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.eql({_id: oid, foo: true, bar: false});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('stores an array as is', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created = await rep.create({foo: null});
|
|
|
+ const id = created[DEF_PK];
|
|
|
+ const replaced = await rep.replaceById(id, {foo: ['bar']});
|
|
|
+ expect(replaced).to.be.eql({[DEF_PK]: id, foo: ['bar']});
|
|
|
+ const oid = new ObjectId(id);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.eql({_id: oid, foo: ['bar']});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('stores an object as is', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created = await rep.create({foo: null});
|
|
|
+ const id = created[DEF_PK];
|
|
|
+ const replaced = await rep.replaceById(id, {foo: {bar: 10}});
|
|
|
+ expect(replaced).to.be.eql({[DEF_PK]: id, foo: {bar: 10}});
|
|
|
+ const oid = new ObjectId(id);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.eql({_id: oid, foo: {bar: 10}});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('stores an undefined as null', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created = await rep.create({foo: 10});
|
|
|
+ const id = created[DEF_PK];
|
|
|
+ const replaced = await rep.replaceById(id, {foo: undefined});
|
|
|
+ expect(replaced).to.be.eql({[DEF_PK]: id, foo: null});
|
|
|
+ const oid = new ObjectId(id);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.eql({_id: oid, foo: null});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('stores an null as is', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created = await rep.create({foo: 10});
|
|
|
+ const id = created[DEF_PK];
|
|
|
+ const replaced = await rep.replaceById(id, {foo: null});
|
|
|
+ expect(replaced).to.be.eql({[DEF_PK]: id, foo: null});
|
|
|
+ const oid = new ObjectId(id);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.eql({_id: oid, foo: null});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('uses a short fields clause to filter results', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created = await rep.create({foo: 10, bar: 20});
|
|
|
+ const id = created[DEF_PK];
|
|
|
+ const replaced = await rep.replaceById(
|
|
|
+ id,
|
|
|
+ {foo: 15, bar: 25},
|
|
|
+ {fields: 'foo'},
|
|
|
+ );
|
|
|
+ expect(replaced).to.be.eql({[DEF_PK]: id, foo: 15});
|
|
|
+ const oid = new ObjectId(id);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.eql({_id: oid, foo: 15, bar: 25});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('uses a full fields clause to filter results', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created = await rep.create({foo: 10, bar: 20, baz: 30});
|
|
|
+ const id = created[DEF_PK];
|
|
|
+ const replaced = await rep.replaceById(
|
|
|
+ id,
|
|
|
+ {foo: 15, bar: 25, baz: 35},
|
|
|
+ {fields: ['foo', 'bar']},
|
|
|
+ );
|
|
|
+ expect(replaced).to.be.eql({[DEF_PK]: id, foo: 15, bar: 25});
|
|
|
+ const oid = new ObjectId(id);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.eql({_id: oid, foo: 15, bar: 25, baz: 35});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('a fields clause uses property names instead of column names', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({
|
|
|
+ name: 'model',
|
|
|
+ datasource: 'mongodb',
|
|
|
+ properties: {
|
|
|
+ foo: {
|
|
|
+ type: DataType.NUMBER,
|
|
|
+ columnName: 'fooCol',
|
|
|
+ },
|
|
|
+ bar: {
|
|
|
+ type: DataType.NUMBER,
|
|
|
+ columnName: 'barCol',
|
|
|
+ },
|
|
|
+ baz: {
|
|
|
+ type: DataType.NUMBER,
|
|
|
+ columnName: 'bazCol',
|
|
|
+ },
|
|
|
+ },
|
|
|
+ });
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created = await rep.create(
|
|
|
+ {foo: 10, bar: 20, baz: 30},
|
|
|
+ {fields: ['fooCol', 'barCol']},
|
|
|
+ );
|
|
|
+ const id = created[DEF_PK];
|
|
|
+ const replaced = await rep.replaceById(
|
|
|
+ id,
|
|
|
+ {foo: 15, bar: 25, baz: 35},
|
|
|
+ {fields: ['fooCol', 'barCol']},
|
|
|
+ );
|
|
|
+ expect(replaced).to.be.eql({[DEF_PK]: replaced[DEF_PK]});
|
|
|
+ const oid = new ObjectId(id);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.eql({_id: oid, fooCol: 15, barCol: 25, bazCol: 35});
|
|
|
+ });
|
|
|
+ });
|
|
|
+
|
|
|
+ describe('patchById', function () {
|
|
|
+ it('updates only provided properties by a given identifier', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created = await rep.create({foo: 10});
|
|
|
+ const id = created[DEF_PK];
|
|
|
+ const patched = await rep.patchById(id, {bar: 20});
|
|
|
+ expect(patched).to.be.eql({[DEF_PK]: id, foo: 10, bar: 20});
|
|
|
+ const oid = new ObjectId(id);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.eql({_id: oid, foo: 10, bar: 20});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('does not throw an error if a partial data does not have required property', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({
|
|
|
+ name: 'model',
|
|
|
+ datasource: 'mongodb',
|
|
|
+ properties: {
|
|
|
+ foo: {
|
|
|
+ type: DataType.NUMBER,
|
|
|
+ required: true,
|
|
|
+ },
|
|
|
+ },
|
|
|
+ });
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const {insertedId: oid} = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .insertOne({bar: 10});
|
|
|
+ const patched = await rep.patchById(oid, {baz: 20});
|
|
|
+ const id = String(oid);
|
|
|
+ expect(patched).to.be.eql({[DEF_PK]: id, bar: 10, baz: 20});
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.eql({_id: oid, bar: 10, baz: 20});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ignores identifier value in a given data in case of a default primary key', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ await rep.create({[DEF_PK]: 'foo', prop: 10});
|
|
|
+ const patched = await rep.patchById('foo', {
|
|
|
+ [DEF_PK]: 'bar',
|
|
|
+ prop: 20,
|
|
|
+ });
|
|
|
+ expect(patched).to.be.eql({[DEF_PK]: 'foo', prop: 20});
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: 'foo'});
|
|
|
+ expect(rawData).to.be.eql({_id: 'foo', prop: 20});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('ignores identifier value in a given data in case of a custom primary key', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({
|
|
|
+ name: 'model',
|
|
|
+ datasource: 'mongodb',
|
|
|
+ properties: {
|
|
|
+ myId: {
|
|
|
+ type: DataType.STRING,
|
|
|
+ primaryKey: true,
|
|
|
+ columnName: '_id',
|
|
|
+ },
|
|
|
+ },
|
|
|
+ });
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ await rep.create({myId: 'foo', prop: 10});
|
|
|
+ const patched = await rep.patchById('foo', {myId: 'bar', prop: 20});
|
|
|
+ expect(patched).to.be.eql({myId: 'foo', prop: 20});
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: 'foo'});
|
|
|
+ expect(rawData).to.be.eql({_id: 'foo', prop: 20});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('throws an error if a given identifier does not exist', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const oid = new ObjectId();
|
|
|
+ const promise = rep.patchById(oid, {foo: 10});
|
|
|
+ await expect(promise).to.be.rejectedWith(
|
|
|
+ format('Identifier "%s" is not found.', oid),
|
|
|
+ );
|
|
|
+ });
|
|
|
+
|
|
|
+ it('throws an error for a custom primary key', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({
|
|
|
+ name: 'model',
|
|
|
+ datasource: 'mongodb',
|
|
|
+ properties: {
|
|
|
+ myId: {
|
|
|
+ type: DataType.ANY,
|
|
|
+ primaryKey: true,
|
|
|
+ },
|
|
|
+ },
|
|
|
+ });
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const promise = rep.patchById('id', {foo: 10});
|
|
|
+ await expect(promise).to.be.rejectedWith(
|
|
|
+ 'MongoDB is not supporting custom names of the primary key. ' +
|
|
|
+ 'Do use "id" as a primary key instead of "myId".',
|
|
|
+ );
|
|
|
+ });
|
|
|
+
|
|
|
+ it('uses a specified column name for a regular property', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({
|
|
|
+ name: 'model',
|
|
|
+ datasource: 'mongodb',
|
|
|
+ properties: {
|
|
|
+ foo: {
|
|
|
+ type: DataType.NUMBER,
|
|
|
+ columnName: 'bar',
|
|
|
+ },
|
|
|
+ },
|
|
|
+ });
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created = await rep.create({foo: 10});
|
|
|
+ const id = created[DEF_PK];
|
|
|
+ const patched = await rep.replaceById(id, {foo: 20});
|
|
|
+ expect(patched).to.be.eql({[DEF_PK]: id, foo: 20});
|
|
|
+ const oid = new ObjectId(id);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.eql({_id: oid, bar: 20});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('stores a Date instance as date and returns string type', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const date = new Date();
|
|
|
+ const dateString = date.toISOString();
|
|
|
+ const created = await rep.create({date: null});
|
|
|
+ const id = created[DEF_PK];
|
|
|
+ const patched = await rep.patchById(id, {date});
|
|
|
+ expect(patched).to.be.eql({[DEF_PK]: id, date: dateString});
|
|
|
+ const oid = new ObjectId(id);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.eql({_id: oid, date});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('stores a Date string as date and returns string type', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const date = new Date();
|
|
|
+ const dateString = date.toISOString();
|
|
|
+ const created = await rep.create({date: null});
|
|
|
+ const id = created[DEF_PK];
|
|
|
+ const patched = await rep.patchById(id, {date: dateString});
|
|
|
+ expect(patched).to.be.eql({[DEF_PK]: id, date: dateString});
|
|
|
+ const oid = new ObjectId(id);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.eql({_id: oid, date});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('stores a string as is', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created = await rep.create({foo: null});
|
|
|
+ const id = created[DEF_PK];
|
|
|
+ const patched = await rep.patchById(id, {foo: 'str'});
|
|
|
+ expect(patched).to.be.eql({[DEF_PK]: id, foo: 'str'});
|
|
|
+ const oid = new ObjectId(id);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.eql({_id: oid, foo: 'str'});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('stores a number as is', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created = await rep.create({foo: null});
|
|
|
+ const id = created[DEF_PK];
|
|
|
+ const patched = await rep.patchById(id, {foo: 10});
|
|
|
+ expect(patched).to.be.eql({[DEF_PK]: id, foo: 10});
|
|
|
+ const oid = new ObjectId(id);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.eql({_id: oid, foo: 10});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('stores a boolean as is', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created = await rep.create({foo: null, bar: null});
|
|
|
+ const id = created[DEF_PK];
|
|
|
+ const patched = await rep.patchById(id, {foo: true, bar: false});
|
|
|
+ expect(patched).to.be.eql({[DEF_PK]: id, foo: true, bar: false});
|
|
|
+ const oid = new ObjectId(id);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.eql({_id: oid, foo: true, bar: false});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('stores an array as is', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created = await rep.create({foo: null});
|
|
|
+ const id = created[DEF_PK];
|
|
|
+ const patched = await rep.patchById(id, {foo: ['bar']});
|
|
|
+ expect(patched).to.be.eql({[DEF_PK]: id, foo: ['bar']});
|
|
|
+ const oid = new ObjectId(id);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.eql({_id: oid, foo: ['bar']});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('stores an object as is', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created = await rep.create({foo: null});
|
|
|
+ const id = created[DEF_PK];
|
|
|
+ const patched = await rep.patchById(id, {foo: {bar: 10}});
|
|
|
+ expect(patched).to.be.eql({[DEF_PK]: id, foo: {bar: 10}});
|
|
|
+ const oid = new ObjectId(id);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.eql({_id: oid, foo: {bar: 10}});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('stores an undefined as null', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created = await rep.create({foo: 10});
|
|
|
+ const id = created[DEF_PK];
|
|
|
+ const patched = await rep.patchById(id, {foo: undefined});
|
|
|
+ expect(patched).to.be.eql({[DEF_PK]: id, foo: null});
|
|
|
+ const oid = new ObjectId(id);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.eql({_id: oid, foo: null});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('stores an null as is', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created = await rep.create({foo: 10});
|
|
|
+ const id = created[DEF_PK];
|
|
|
+ const patched = await rep.patchById(id, {foo: null});
|
|
|
+ expect(patched).to.be.eql({[DEF_PK]: id, foo: null});
|
|
|
+ const oid = new ObjectId(id);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.eql({_id: oid, foo: null});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('uses a short fields clause to filter results', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created = await rep.create({foo: 10, bar: 20});
|
|
|
+ const id = created[DEF_PK];
|
|
|
+ const patched = await rep.patchById(
|
|
|
+ id,
|
|
|
+ {foo: 15, bar: 25},
|
|
|
+ {fields: 'foo'},
|
|
|
+ );
|
|
|
+ expect(patched).to.be.eql({[DEF_PK]: id, foo: 15});
|
|
|
+ const oid = new ObjectId(id);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.eql({_id: oid, foo: 15, bar: 25});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('uses a full fields clause to filter results', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created = await rep.create({foo: 10, bar: 20, baz: 30});
|
|
|
+ const id = created[DEF_PK];
|
|
|
+ const patched = await rep.patchById(
|
|
|
+ id,
|
|
|
+ {foo: 15, bar: 25, baz: 35},
|
|
|
+ {fields: ['foo', 'bar']},
|
|
|
+ );
|
|
|
+ expect(patched).to.be.eql({[DEF_PK]: id, foo: 15, bar: 25});
|
|
|
+ const oid = new ObjectId(id);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.eql({_id: oid, foo: 15, bar: 25, baz: 35});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('a fields clause uses property names instead of column names', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({
|
|
|
+ name: 'model',
|
|
|
+ datasource: 'mongodb',
|
|
|
+ properties: {
|
|
|
+ foo: {
|
|
|
+ type: DataType.NUMBER,
|
|
|
+ columnName: 'fooCol',
|
|
|
+ },
|
|
|
+ bar: {
|
|
|
+ type: DataType.NUMBER,
|
|
|
+ columnName: 'barCol',
|
|
|
+ },
|
|
|
+ baz: {
|
|
|
+ type: DataType.NUMBER,
|
|
|
+ columnName: 'bazCol',
|
|
|
+ },
|
|
|
+ },
|
|
|
+ });
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created = await rep.create(
|
|
|
+ {foo: 10, bar: 20, baz: 30},
|
|
|
+ {fields: ['fooCol', 'barCol']},
|
|
|
+ );
|
|
|
+ const id = created[DEF_PK];
|
|
|
+ const patched = await rep.patchById(
|
|
|
+ id,
|
|
|
+ {foo: 15, bar: 25, baz: 35},
|
|
|
+ {fields: ['fooCol', 'barCol']},
|
|
|
+ );
|
|
|
+ expect(patched).to.be.eql({[DEF_PK]: patched[DEF_PK]});
|
|
|
+ const oid = new ObjectId(id);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .findOne({_id: oid});
|
|
|
+ expect(rawData).to.be.eql({_id: oid, fooCol: 15, barCol: 25, bazCol: 35});
|
|
|
+ });
|
|
|
+ });
|
|
|
+
|
|
|
+ describe('find', function () {
|
|
|
+ it('returns an empty array', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const result = await rep.find();
|
|
|
+ expect(result).to.be.empty;
|
|
|
+ expect(result).to.be.instanceOf(Array);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('returns all items', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const doc1 = await rep.create({foo: 1});
|
|
|
+ const doc2 = await rep.create({bar: 2});
|
|
|
+ const doc3 = await rep.create({baz: 3});
|
|
|
+ const result = await rep.find();
|
|
|
+ expect(result).to.be.eql([doc1, doc2, doc3]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('uses a short fields clause to filter results', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created1 = await rep.create({foo: 10, bar: 20});
|
|
|
+ const created2 = await rep.create({foo: 20, bar: 30});
|
|
|
+ const id1 = created1[DEF_PK];
|
|
|
+ const id2 = created2[DEF_PK];
|
|
|
+ const result = await rep.find({fields: 'foo'});
|
|
|
+ expect(result).to.be.eql([
|
|
|
+ {[DEF_PK]: id1, foo: 10},
|
|
|
+ {[DEF_PK]: id2, foo: 20},
|
|
|
+ ]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('uses a full fields clause to filter results', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created1 = await rep.create({foo: 10, bar: 20, baz: 30});
|
|
|
+ const created2 = await rep.create({foo: 20, bar: 30, baz: 40});
|
|
|
+ const id1 = created1[DEF_PK];
|
|
|
+ const id2 = created2[DEF_PK];
|
|
|
+ const result = await rep.find({fields: ['foo', 'bar']});
|
|
|
+ expect(result).to.be.eql([
|
|
|
+ {[DEF_PK]: id1, foo: 10, bar: 20},
|
|
|
+ {[DEF_PK]: id2, foo: 20, bar: 30},
|
|
|
+ ]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('a fields clause uses property names instead of column names', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({
|
|
|
+ name: 'model',
|
|
|
+ datasource: 'mongodb',
|
|
|
+ properties: {
|
|
|
+ foo: {
|
|
|
+ type: DataType.NUMBER,
|
|
|
+ columnName: 'fooCol',
|
|
|
+ },
|
|
|
+ bar: {
|
|
|
+ type: DataType.NUMBER,
|
|
|
+ columnName: 'barCol',
|
|
|
+ },
|
|
|
+ baz: {
|
|
|
+ type: DataType.NUMBER,
|
|
|
+ columnName: 'bazCol',
|
|
|
+ },
|
|
|
+ },
|
|
|
+ });
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created1 = await rep.create({foo: 10, bar: 20, baz: 30});
|
|
|
+ const created2 = await rep.create({foo: 20, bar: 30, baz: 40});
|
|
|
+ const id1 = created1[DEF_PK];
|
|
|
+ const id2 = created2[DEF_PK];
|
|
|
+ const result = await rep.find({fields: ['fooCol', 'barCol']});
|
|
|
+ expect(result).to.be.eql([{[DEF_PK]: id1}, {[DEF_PK]: id2}]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('uses a short order clause to sort results', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created1 = await rep.create({foo: 20});
|
|
|
+ const created2 = await rep.create({foo: 5});
|
|
|
+ const created3 = await rep.create({foo: 10});
|
|
|
+ const result1 = await rep.find({order: 'foo'});
|
|
|
+ const result2 = await rep.find({order: 'foo ASC'});
|
|
|
+ const result3 = await rep.find({order: 'foo DESC'});
|
|
|
+ expect(result1).to.be.eql([
|
|
|
+ {[DEF_PK]: created2[DEF_PK], foo: 5},
|
|
|
+ {[DEF_PK]: created3[DEF_PK], foo: 10},
|
|
|
+ {[DEF_PK]: created1[DEF_PK], foo: 20},
|
|
|
+ ]);
|
|
|
+ expect(result2).to.be.eql([
|
|
|
+ {[DEF_PK]: created2[DEF_PK], foo: 5},
|
|
|
+ {[DEF_PK]: created3[DEF_PK], foo: 10},
|
|
|
+ {[DEF_PK]: created1[DEF_PK], foo: 20},
|
|
|
+ ]);
|
|
|
+ expect(result3).to.be.eql([
|
|
|
+ {[DEF_PK]: created1[DEF_PK], foo: 20},
|
|
|
+ {[DEF_PK]: created3[DEF_PK], foo: 10},
|
|
|
+ {[DEF_PK]: created2[DEF_PK], foo: 5},
|
|
|
+ ]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('uses a full order clause to sort results', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created1 = await rep.create({foo: 20, bar: 'b'});
|
|
|
+ const created2 = await rep.create({foo: 5, bar: 'b'});
|
|
|
+ const created3 = await rep.create({foo: 10, bar: 'a'});
|
|
|
+ const result1 = await rep.find({order: ['bar DESC', 'foo']});
|
|
|
+ const result2 = await rep.find({order: ['bar', 'foo ASC']});
|
|
|
+ expect(result1).to.be.eql([
|
|
|
+ {[DEF_PK]: created2[DEF_PK], foo: 5, bar: 'b'},
|
|
|
+ {[DEF_PK]: created1[DEF_PK], foo: 20, bar: 'b'},
|
|
|
+ {[DEF_PK]: created3[DEF_PK], foo: 10, bar: 'a'},
|
|
|
+ ]);
|
|
|
+ expect(result2).to.be.eql([
|
|
|
+ {[DEF_PK]: created3[DEF_PK], foo: 10, bar: 'a'},
|
|
|
+ {[DEF_PK]: created2[DEF_PK], foo: 5, bar: 'b'},
|
|
|
+ {[DEF_PK]: created1[DEF_PK], foo: 20, bar: 'b'},
|
|
|
+ ]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('an order clause uses property names instead of column names', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({
|
|
|
+ name: 'model',
|
|
|
+ datasource: 'mongodb',
|
|
|
+ properties: {
|
|
|
+ foo: {
|
|
|
+ type: DataType.NUMBER,
|
|
|
+ columnName: 'fooCol',
|
|
|
+ },
|
|
|
+ bar: {
|
|
|
+ type: DataType.STRING,
|
|
|
+ columnName: 'barCol',
|
|
|
+ },
|
|
|
+ },
|
|
|
+ });
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created1 = await rep.create({foo: 20, bar: 'b'});
|
|
|
+ const created2 = await rep.create({foo: 5, bar: 'b'});
|
|
|
+ const created3 = await rep.create({foo: 10, bar: 'a'});
|
|
|
+ const result1 = await rep.find({order: ['bar DESC', 'foo']});
|
|
|
+ const result2 = await rep.find({order: ['bar', 'foo ASC']});
|
|
|
+ expect(result1).to.be.eql([
|
|
|
+ {[DEF_PK]: created2[DEF_PK], foo: 5, bar: 'b'},
|
|
|
+ {[DEF_PK]: created1[DEF_PK], foo: 20, bar: 'b'},
|
|
|
+ {[DEF_PK]: created3[DEF_PK], foo: 10, bar: 'a'},
|
|
|
+ ]);
|
|
|
+ expect(result2).to.be.eql([
|
|
|
+ {[DEF_PK]: created3[DEF_PK], foo: 10, bar: 'a'},
|
|
|
+ {[DEF_PK]: created2[DEF_PK], foo: 5, bar: 'b'},
|
|
|
+ {[DEF_PK]: created1[DEF_PK], foo: 20, bar: 'b'},
|
|
|
+ ]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('uses a limit clause to filter results', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created1 = await rep.create({foo: 10});
|
|
|
+ const created2 = await rep.create({foo: 20});
|
|
|
+ await rep.create({foo: 30});
|
|
|
+ const result = await rep.find({limit: 2});
|
|
|
+ expect(result).to.be.eql([created1, created2]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('uses a skip clause to filter results', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ await rep.create({foo: 10});
|
|
|
+ const created2 = await rep.create({foo: 20});
|
|
|
+ const created3 = await rep.create({foo: 30});
|
|
|
+ const result = await rep.find({skip: 1});
|
|
|
+ expect(result).to.be.eql([created2, created3]);
|
|
|
+ });
|
|
|
+
|
|
|
+ describe('uses a where clause to filter results', function () {
|
|
|
+ it('matches by a document subset', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created1 = await rep.create({foo: 5, bar: 'b'});
|
|
|
+ const created2 = await rep.create({foo: 10, bar: 'a'});
|
|
|
+ const result1 = await rep.find({where: {foo: 10}});
|
|
|
+ const result2 = await rep.find({where: {foo: 5, bar: 'b'}});
|
|
|
+ expect(result1).to.be.eql([
|
|
|
+ {
|
|
|
+ [DEF_PK]: created2[DEF_PK],
|
|
|
+ foo: 10,
|
|
|
+ bar: 'a',
|
|
|
+ },
|
|
|
+ ]);
|
|
|
+ expect(result2).to.be.eql([
|
|
|
+ {
|
|
|
+ [DEF_PK]: created1[DEF_PK],
|
|
|
+ foo: 5,
|
|
|
+ bar: 'b',
|
|
|
+ },
|
|
|
+ ]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "eq" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ await rep.create({foo: 5});
|
|
|
+ const created2 = await rep.create({foo: 10});
|
|
|
+ const created3 = await rep.create({foo: 10});
|
|
|
+ const result = await rep.find({where: {foo: {eq: 10}}});
|
|
|
+ expect(result).to.be.eql([
|
|
|
+ {[DEF_PK]: created2[DEF_PK], foo: 10},
|
|
|
+ {[DEF_PK]: created3[DEF_PK], foo: 10},
|
|
|
+ ]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "neq" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created1 = await rep.create({foo: 5});
|
|
|
+ await rep.create({foo: 10});
|
|
|
+ await rep.create({foo: 10});
|
|
|
+ const result = await rep.find({where: {foo: {neq: 10}}});
|
|
|
+ expect(result).to.be.eql([{[DEF_PK]: created1[DEF_PK], foo: 5}]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "gt" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ await rep.create({foo: 5});
|
|
|
+ await rep.create({foo: 10});
|
|
|
+ const created3 = await rep.create({foo: 15});
|
|
|
+ const result = await rep.find({where: {foo: {gt: 10}}});
|
|
|
+ expect(result).to.be.eql([{[DEF_PK]: created3[DEF_PK], foo: 15}]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "lt" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created1 = await rep.create({foo: 5});
|
|
|
+ await rep.create({foo: 10});
|
|
|
+ await rep.create({foo: 15});
|
|
|
+ const result = await rep.find({where: {foo: {lt: 10}}});
|
|
|
+ expect(result).to.be.eql([{[DEF_PK]: created1[DEF_PK], foo: 5}]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "gte" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ await rep.create({foo: 5});
|
|
|
+ const created2 = await rep.create({foo: 10});
|
|
|
+ const created3 = await rep.create({foo: 15});
|
|
|
+ const result = await rep.find({where: {foo: {gte: 10}}});
|
|
|
+ expect(result).to.be.eql([
|
|
|
+ {[DEF_PK]: created2[DEF_PK], foo: 10},
|
|
|
+ {[DEF_PK]: created3[DEF_PK], foo: 15},
|
|
|
+ ]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "lte" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created1 = await rep.create({foo: 5});
|
|
|
+ const created2 = await rep.create({foo: 10});
|
|
|
+ await rep.create({foo: 15});
|
|
|
+ const result = await rep.find({where: {foo: {lte: 10}}});
|
|
|
+ expect(result).to.be.eql([
|
|
|
+ {[DEF_PK]: created1[DEF_PK], foo: 5},
|
|
|
+ {[DEF_PK]: created2[DEF_PK], foo: 10},
|
|
|
+ ]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "inq" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created1 = await rep.create({foo: 5});
|
|
|
+ const created2 = await rep.create({foo: 10});
|
|
|
+ await rep.create({foo: 15});
|
|
|
+ const result = await rep.find({where: {foo: {inq: [5, 10]}}});
|
|
|
+ expect(result).to.be.eql([
|
|
|
+ {[DEF_PK]: created1[DEF_PK], foo: 5},
|
|
|
+ {[DEF_PK]: created2[DEF_PK], foo: 10},
|
|
|
+ ]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "nin" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ await rep.create({foo: 5});
|
|
|
+ await rep.create({foo: 10});
|
|
|
+ const created3 = await rep.create({foo: 15});
|
|
|
+ const result = await rep.find({where: {foo: {nin: [5, 10]}}});
|
|
|
+ expect(result).to.be.eql([{[DEF_PK]: created3[DEF_PK], foo: 15}]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "between" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ await rep.create({foo: 5});
|
|
|
+ const created2 = await rep.create({foo: 10});
|
|
|
+ const created3 = await rep.create({foo: 15});
|
|
|
+ await rep.create({foo: 20});
|
|
|
+ const result = await rep.find({where: {foo: {between: [9, 16]}}});
|
|
|
+ expect(result).to.be.eql([
|
|
|
+ {[DEF_PK]: created2[DEF_PK], foo: 10},
|
|
|
+ {[DEF_PK]: created3[DEF_PK], foo: 15},
|
|
|
+ ]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "exists" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created1 = await rep.create({});
|
|
|
+ const created2 = await rep.create({foo: undefined});
|
|
|
+ const created3 = await rep.create({foo: null});
|
|
|
+ const created4 = await rep.create({foo: 10});
|
|
|
+ const result1 = await rep.find({where: {foo: {exists: true}}});
|
|
|
+ const result2 = await rep.find({where: {foo: {exists: false}}});
|
|
|
+ expect(result1).to.be.eql([
|
|
|
+ {[DEF_PK]: created2[DEF_PK], foo: null},
|
|
|
+ {[DEF_PK]: created3[DEF_PK], foo: null},
|
|
|
+ {[DEF_PK]: created4[DEF_PK], foo: 10},
|
|
|
+ ]);
|
|
|
+ expect(result2).to.be.eql([{[DEF_PK]: created1[DEF_PK]}]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "like" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ await rep.create({foo: 'lorem ipsum'});
|
|
|
+ const created2 = await rep.create({foo: 'dolor sit amet'});
|
|
|
+ await rep.create({foo: 'DOLOR SIT AMET'});
|
|
|
+ const created4 = await rep.create({foo: 'sit amet'});
|
|
|
+ const result = await rep.find({where: {foo: {like: 'sit amet'}}});
|
|
|
+ expect(result).to.be.eql([
|
|
|
+ {[DEF_PK]: created2[DEF_PK], foo: 'dolor sit amet'},
|
|
|
+ {[DEF_PK]: created4[DEF_PK], foo: 'sit amet'},
|
|
|
+ ]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "ilike" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ await rep.create({foo: 'lorem ipsum'});
|
|
|
+ const created2 = await rep.create({foo: 'dolor sit amet'});
|
|
|
+ const created3 = await rep.create({foo: 'DOLOR SIT AMET'});
|
|
|
+ const created4 = await rep.create({foo: 'sit amet'});
|
|
|
+ const result = await rep.find({where: {foo: {ilike: 'sit amet'}}});
|
|
|
+ expect(result).to.be.eql([
|
|
|
+ {[DEF_PK]: created2[DEF_PK], foo: 'dolor sit amet'},
|
|
|
+ {[DEF_PK]: created3[DEF_PK], foo: 'DOLOR SIT AMET'},
|
|
|
+ {[DEF_PK]: created4[DEF_PK], foo: 'sit amet'},
|
|
|
+ ]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "nlike" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created1 = await rep.create({foo: 'lorem ipsum'});
|
|
|
+ await rep.create({foo: 'dolor sit amet'});
|
|
|
+ const created3 = await rep.create({foo: 'DOLOR SIT AMET'});
|
|
|
+ await rep.create({foo: 'sit amet'});
|
|
|
+ const result = await rep.find({where: {foo: {nlike: 'sit amet'}}});
|
|
|
+ expect(result).to.be.eql([
|
|
|
+ {[DEF_PK]: created1[DEF_PK], foo: 'lorem ipsum'},
|
|
|
+ {[DEF_PK]: created3[DEF_PK], foo: 'DOLOR SIT AMET'},
|
|
|
+ ]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "nilike" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created1 = await rep.create({foo: 'lorem ipsum'});
|
|
|
+ await rep.create({foo: 'dolor sit amet'});
|
|
|
+ await rep.create({foo: 'DOLOR SIT AMET'});
|
|
|
+ await rep.create({foo: 'sit amet'});
|
|
|
+ const result = await rep.find({where: {foo: {nilike: 'sit amet'}}});
|
|
|
+ expect(result).to.be.eql([
|
|
|
+ {[DEF_PK]: created1[DEF_PK], foo: 'lorem ipsum'},
|
|
|
+ ]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "regexp" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ await rep.create({foo: 'lorem ipsum'});
|
|
|
+ const created2 = await rep.create({foo: 'dolor sit amet'});
|
|
|
+ await rep.create({foo: 'DOLOR SIT AMET'});
|
|
|
+ const created4 = await rep.create({foo: 'sit amet'});
|
|
|
+ const result = await rep.find({where: {foo: {regexp: 'sit am+'}}});
|
|
|
+ expect(result).to.be.eql([
|
|
|
+ {[DEF_PK]: created2[DEF_PK], foo: 'dolor sit amet'},
|
|
|
+ {[DEF_PK]: created4[DEF_PK], foo: 'sit amet'},
|
|
|
+ ]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "regexp" operator with flags', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ await rep.create({foo: 'lorem ipsum'});
|
|
|
+ const created2 = await rep.create({foo: 'dolor sit amet'});
|
|
|
+ const created3 = await rep.create({foo: 'DOLOR SIT AMET'});
|
|
|
+ const created4 = await rep.create({foo: 'sit amet'});
|
|
|
+ const result = await rep.find({
|
|
|
+ where: {
|
|
|
+ foo: {regexp: 'sit am+', flags: 'i'},
|
|
|
+ },
|
|
|
+ });
|
|
|
+ expect(result).to.be.eql([
|
|
|
+ {[DEF_PK]: created2[DEF_PK], foo: 'dolor sit amet'},
|
|
|
+ {[DEF_PK]: created3[DEF_PK], foo: 'DOLOR SIT AMET'},
|
|
|
+ {[DEF_PK]: created4[DEF_PK], foo: 'sit amet'},
|
|
|
+ ]);
|
|
|
+ });
|
|
|
+ });
|
|
|
+ });
|
|
|
+
|
|
|
+ describe('findById', function () {
|
|
|
+ it('throws an error if a given identifier does not exist', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const oid = new ObjectId();
|
|
|
+ const promise = rep.findById(oid);
|
|
|
+ await expect(promise).to.be.rejectedWith(
|
|
|
+ format('Identifier "%s" is not found.', oid),
|
|
|
+ );
|
|
|
+ });
|
|
|
+
|
|
|
+ it('uses a short fields clause to filter results', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created = await rep.create({foo: 10, bar: 20});
|
|
|
+ const id = created[DEF_PK];
|
|
|
+ const result = await rep.findById(id, {fields: 'foo'});
|
|
|
+ expect(result).to.be.eql({[DEF_PK]: id, foo: 10});
|
|
|
+ });
|
|
|
+
|
|
|
+ it('uses a full fields clause to filter results', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created = await rep.create({foo: 10, bar: 20, baz: 30});
|
|
|
+ const id = created[DEF_PK];
|
|
|
+ const result = await rep.findById(id, {fields: ['foo', 'bar']});
|
|
|
+ expect(result).to.be.eql({[DEF_PK]: id, foo: 10, bar: 20});
|
|
|
+ });
|
|
|
+ });
|
|
|
+
|
|
|
+ describe('delete', function () {
|
|
|
+ it('removes all table items and returns their number', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ await rep.create({foo: 1});
|
|
|
+ await rep.create({foo: 2});
|
|
|
+ await rep.create({foo: 3});
|
|
|
+ const result = await rep.delete();
|
|
|
+ expect(result).to.be.eql(3);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .find()
|
|
|
+ .toArray();
|
|
|
+ expect(rawData).to.be.empty;
|
|
|
+ });
|
|
|
+
|
|
|
+ describe('removes by a where clause', function () {
|
|
|
+ it('removes by a document subset', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created1 = await rep.create({foo: 5});
|
|
|
+ await rep.create({foo: 10});
|
|
|
+ const result = await rep.delete({foo: 10});
|
|
|
+ expect(result).to.be.eq(1);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .find()
|
|
|
+ .toArray();
|
|
|
+ expect(rawData).to.be.eql([
|
|
|
+ {_id: new ObjectId(created1[DEF_PK]), foo: 5},
|
|
|
+ ]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "eq" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created1 = await rep.create({foo: 5});
|
|
|
+ await rep.create({foo: 10});
|
|
|
+ await rep.create({foo: 10});
|
|
|
+ const result = await rep.delete({foo: {eq: 10}});
|
|
|
+ expect(result).to.be.eq(2);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .find()
|
|
|
+ .toArray();
|
|
|
+ expect(rawData).to.be.eql([
|
|
|
+ {_id: new ObjectId(created1[DEF_PK]), foo: 5},
|
|
|
+ ]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "neq" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ await rep.create({foo: 5});
|
|
|
+ await rep.create({foo: 5});
|
|
|
+ const created3 = await rep.create({foo: 10});
|
|
|
+ const result = await rep.delete({foo: {neq: 10}});
|
|
|
+ expect(result).to.be.eq(2);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .find()
|
|
|
+ .toArray();
|
|
|
+ expect(rawData).to.be.eql([
|
|
|
+ {_id: new ObjectId(created3[DEF_PK]), foo: 10},
|
|
|
+ ]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "gt" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created1 = await rep.create({foo: 5});
|
|
|
+ const created2 = await rep.create({foo: 10});
|
|
|
+ await rep.create({foo: 15});
|
|
|
+ const result = await rep.delete({foo: {gt: 10}});
|
|
|
+ expect(result).to.be.eq(1);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .find()
|
|
|
+ .toArray();
|
|
|
+ expect(rawData).to.be.eql([
|
|
|
+ {_id: new ObjectId(created1[DEF_PK]), foo: 5},
|
|
|
+ {_id: new ObjectId(created2[DEF_PK]), foo: 10},
|
|
|
+ ]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "lt" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ await rep.create({foo: 5});
|
|
|
+ const created2 = await rep.create({foo: 10});
|
|
|
+ const created3 = await rep.create({foo: 15});
|
|
|
+ const result = await rep.delete({foo: {lt: 10}});
|
|
|
+ expect(result).to.be.eq(1);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .find()
|
|
|
+ .toArray();
|
|
|
+ expect(rawData).to.be.eql([
|
|
|
+ {_id: new ObjectId(created2[DEF_PK]), foo: 10},
|
|
|
+ {_id: new ObjectId(created3[DEF_PK]), foo: 15},
|
|
|
+ ]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "gte" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created1 = await rep.create({foo: 5});
|
|
|
+ await rep.create({foo: 10});
|
|
|
+ await rep.create({foo: 15});
|
|
|
+ const result = await rep.delete({foo: {gte: 10}});
|
|
|
+ expect(result).to.be.eq(2);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .find()
|
|
|
+ .toArray();
|
|
|
+ expect(rawData).to.be.eql([
|
|
|
+ {_id: new ObjectId(created1[DEF_PK]), foo: 5},
|
|
|
+ ]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "lte" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ await rep.create({foo: 5});
|
|
|
+ await rep.create({foo: 10});
|
|
|
+ const created3 = await rep.create({foo: 15});
|
|
|
+ const result = await rep.delete({foo: {lte: 10}});
|
|
|
+ expect(result).to.be.eq(2);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .find()
|
|
|
+ .toArray();
|
|
|
+ expect(rawData).to.be.eql([
|
|
|
+ {_id: new ObjectId(created3[DEF_PK]), foo: 15},
|
|
|
+ ]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "inq" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ await rep.create({foo: 5});
|
|
|
+ await rep.create({foo: 10});
|
|
|
+ const created3 = await rep.create({foo: 15});
|
|
|
+ const result = await rep.delete({foo: {inq: [5, 10]}});
|
|
|
+ expect(result).to.be.eq(2);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .find()
|
|
|
+ .toArray();
|
|
|
+ expect(rawData).to.be.eql([
|
|
|
+ {_id: new ObjectId(created3[DEF_PK]), foo: 15},
|
|
|
+ ]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "nin" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created1 = await rep.create({foo: 5});
|
|
|
+ const created2 = await rep.create({foo: 10});
|
|
|
+ await rep.create({foo: 15});
|
|
|
+ const result = await rep.delete({foo: {nin: [5, 10]}});
|
|
|
+ expect(result).to.be.eq(1);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .find()
|
|
|
+ .toArray();
|
|
|
+ expect(rawData).to.be.eql([
|
|
|
+ {_id: new ObjectId(created1[DEF_PK]), foo: 5},
|
|
|
+ {_id: new ObjectId(created2[DEF_PK]), foo: 10},
|
|
|
+ ]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "between" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created1 = await rep.create({foo: 5});
|
|
|
+ await rep.create({foo: 10});
|
|
|
+ await rep.create({foo: 15});
|
|
|
+ const created4 = await rep.create({foo: 20});
|
|
|
+ const result = await rep.delete({foo: {between: [9, 16]}});
|
|
|
+ expect(result).to.be.eq(2);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .find()
|
|
|
+ .toArray();
|
|
|
+ expect(rawData).to.be.eql([
|
|
|
+ {_id: new ObjectId(created1[DEF_PK]), foo: 5},
|
|
|
+ {_id: new ObjectId(created4[DEF_PK]), foo: 20},
|
|
|
+ ]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "exists" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created1 = await rep.create({});
|
|
|
+ await rep.create({foo: undefined});
|
|
|
+ await rep.create({foo: null});
|
|
|
+ await rep.create({foo: 10});
|
|
|
+ const result = await rep.delete({foo: {exists: true}});
|
|
|
+ expect(result).to.be.eq(3);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .find()
|
|
|
+ .toArray();
|
|
|
+ expect(rawData).to.be.eql([{_id: new ObjectId(created1[DEF_PK])}]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "like" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created1 = await rep.create({foo: 'lorem ipsum'});
|
|
|
+ await rep.create({foo: 'dolor sit amet'});
|
|
|
+ const created3 = await rep.create({foo: 'DOLOR SIT AMET'});
|
|
|
+ await rep.create({foo: 'sit amet'});
|
|
|
+ const result = await rep.delete({foo: {like: 'sit amet'}});
|
|
|
+ expect(result).to.be.eq(2);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .find()
|
|
|
+ .toArray();
|
|
|
+ expect(rawData).to.be.eql([
|
|
|
+ {_id: new ObjectId(created1[DEF_PK]), foo: 'lorem ipsum'},
|
|
|
+ {_id: new ObjectId(created3[DEF_PK]), foo: 'DOLOR SIT AMET'},
|
|
|
+ ]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "nlike" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ await rep.create({foo: 'lorem ipsum'});
|
|
|
+ const created2 = await rep.create({foo: 'dolor sit amet'});
|
|
|
+ await rep.create({foo: 'DOLOR SIT AMET'});
|
|
|
+ const created4 = await rep.create({foo: 'sit amet'});
|
|
|
+ const result = await rep.delete({foo: {nlike: 'sit amet'}});
|
|
|
+ expect(result).to.be.eq(2);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .find()
|
|
|
+ .toArray();
|
|
|
+ expect(rawData).to.be.eql([
|
|
|
+ {_id: new ObjectId(created2[DEF_PK]), foo: 'dolor sit amet'},
|
|
|
+ {_id: new ObjectId(created4[DEF_PK]), foo: 'sit amet'},
|
|
|
+ ]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "ilike" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created1 = await rep.create({foo: 'lorem ipsum'});
|
|
|
+ await rep.create({foo: 'dolor sit amet'});
|
|
|
+ await rep.create({foo: 'DOLOR SIT AMET'});
|
|
|
+ await rep.create({foo: 'sit amet'});
|
|
|
+ const result = await rep.delete({foo: {ilike: 'sit amet'}});
|
|
|
+ expect(result).to.be.eq(3);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .find()
|
|
|
+ .toArray();
|
|
|
+ expect(rawData).to.be.eql([
|
|
|
+ {_id: new ObjectId(created1[DEF_PK]), foo: 'lorem ipsum'},
|
|
|
+ ]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "nilike" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ await rep.create({foo: 'lorem ipsum'});
|
|
|
+ const created2 = await rep.create({foo: 'dolor sit amet'});
|
|
|
+ const created3 = await rep.create({foo: 'DOLOR SIT AMET'});
|
|
|
+ const created4 = await rep.create({foo: 'sit amet'});
|
|
|
+ const result = await rep.delete({foo: {nilike: 'sit amet'}});
|
|
|
+ expect(result).to.be.eq(1);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .find()
|
|
|
+ .toArray();
|
|
|
+ expect(rawData).to.be.eql([
|
|
|
+ {_id: new ObjectId(created2[DEF_PK]), foo: 'dolor sit amet'},
|
|
|
+ {_id: new ObjectId(created3[DEF_PK]), foo: 'DOLOR SIT AMET'},
|
|
|
+ {_id: new ObjectId(created4[DEF_PK]), foo: 'sit amet'},
|
|
|
+ ]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "regexp" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created1 = await rep.create({foo: 'lorem ipsum'});
|
|
|
+ await rep.create({foo: 'dolor sit amet'});
|
|
|
+ const created3 = await rep.create({foo: 'DOLOR SIT AMET'});
|
|
|
+ await rep.create({foo: 'sit amet'});
|
|
|
+ const result = await rep.delete({foo: {regexp: 'sit am+'}});
|
|
|
+ expect(result).to.be.eq(2);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .find()
|
|
|
+ .toArray();
|
|
|
+ expect(rawData).to.be.eql([
|
|
|
+ {_id: new ObjectId(created1[DEF_PK]), foo: 'lorem ipsum'},
|
|
|
+ {_id: new ObjectId(created3[DEF_PK]), foo: 'DOLOR SIT AMET'},
|
|
|
+ ]);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "regexp" operator with flags', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const created1 = await rep.create({foo: 'lorem ipsum'});
|
|
|
+ await rep.create({foo: 'dolor sit amet'});
|
|
|
+ await rep.create({foo: 'DOLOR SIT AMET'});
|
|
|
+ await rep.create({foo: 'sit amet'});
|
|
|
+ const result = await rep.delete({foo: {regexp: 'sit am+', flags: 'i'}});
|
|
|
+ expect(result).to.be.eq(3);
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .find()
|
|
|
+ .toArray();
|
|
|
+ expect(rawData).to.be.eql([
|
|
|
+ {_id: new ObjectId(created1[DEF_PK]), foo: 'lorem ipsum'},
|
|
|
+ ]);
|
|
|
+ });
|
|
|
+ });
|
|
|
+ });
|
|
|
+
|
|
|
+ describe('deleteById', function () {
|
|
|
+ it('returns false if a given identifier is not exist', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const oid = new ObjectId();
|
|
|
+ const result = await rep.deleteById(oid);
|
|
|
+ expect(result).to.be.false;
|
|
|
+ });
|
|
|
+
|
|
|
+ it('returns true if an item has removed by a given identifier', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const oid = new ObjectId();
|
|
|
+ await rep.create({[DEF_PK]: oid});
|
|
|
+ const result = await rep.deleteById(oid);
|
|
|
+ expect(result).to.be.true;
|
|
|
+ const rawData = await MDB_CLIENT.db()
|
|
|
+ .collection('model')
|
|
|
+ .find()
|
|
|
+ .toArray();
|
|
|
+ expect(rawData).to.be.empty;
|
|
|
+ });
|
|
|
+ });
|
|
|
+
|
|
|
+ describe('exists', function () {
|
|
|
+ it('returns false if a given identifier is not exist', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const oid = new ObjectId();
|
|
|
+ const result = await rep.exists(oid);
|
|
|
+ expect(result).to.be.false;
|
|
|
+ });
|
|
|
+
|
|
|
+ it('returns true if a given identifier is exist', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const oid = new ObjectId();
|
|
|
+ await rep.create({[DEF_PK]: oid});
|
|
|
+ const result = await rep.exists(oid);
|
|
|
+ expect(result).to.be.true;
|
|
|
+ });
|
|
|
+ });
|
|
|
+
|
|
|
+ describe('count', function () {
|
|
|
+ it('returns zero if nothing to count', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ const result = await rep.count();
|
|
|
+ expect(result).to.be.eq(0);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('returns a number of table items', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ await rep.create({});
|
|
|
+ await rep.create({});
|
|
|
+ await rep.create({});
|
|
|
+ const result = await rep.count();
|
|
|
+ expect(result).to.be.eq(3);
|
|
|
+ });
|
|
|
+
|
|
|
+ describe('uses a where clause to count items', function () {
|
|
|
+ it('matches by a document subset', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ await rep.create({foo: 'a'});
|
|
|
+ await rep.create({foo: 'b'});
|
|
|
+ await rep.create({foo: 'b'});
|
|
|
+ const result = await rep.count({foo: 'b'});
|
|
|
+ expect(result).to.be.eql(2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "eq" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ await rep.create({foo: 5});
|
|
|
+ await rep.create({foo: 10});
|
|
|
+ await rep.create({foo: 10});
|
|
|
+ const result = await rep.count({foo: {eq: 10}});
|
|
|
+ expect(result).to.be.eql(2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "neq" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ await rep.create({foo: 5});
|
|
|
+ await rep.create({foo: 10});
|
|
|
+ await rep.create({foo: 10});
|
|
|
+ const result = await rep.count({foo: {neq: 10}});
|
|
|
+ expect(result).to.be.eq(1);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "gt" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ await rep.create({foo: 5});
|
|
|
+ await rep.create({foo: 10});
|
|
|
+ await rep.create({foo: 15});
|
|
|
+ const result = await rep.count({foo: {gt: 10}});
|
|
|
+ expect(result).to.be.eq(1);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "lt" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ await rep.create({foo: 5});
|
|
|
+ await rep.create({foo: 10});
|
|
|
+ await rep.create({foo: 15});
|
|
|
+ const result = await rep.count({foo: {lt: 10}});
|
|
|
+ expect(result).to.be.eq(1);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "gte" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ await rep.create({foo: 5});
|
|
|
+ await rep.create({foo: 10});
|
|
|
+ await rep.create({foo: 15});
|
|
|
+ const result = await rep.count({foo: {gte: 10}});
|
|
|
+ expect(result).to.be.eq(2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "lte" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ await rep.create({foo: 5});
|
|
|
+ await rep.create({foo: 10});
|
|
|
+ await rep.create({foo: 15});
|
|
|
+ const result = await rep.count({foo: {lte: 10}});
|
|
|
+ expect(result).to.be.eq(2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "inq" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ await rep.create({foo: 5});
|
|
|
+ await rep.create({foo: 10});
|
|
|
+ await rep.create({foo: 15});
|
|
|
+ const result = await rep.count({foo: {inq: [5, 10]}});
|
|
|
+ expect(result).to.be.eq(2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "nin" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ await rep.create({foo: 5});
|
|
|
+ await rep.create({foo: 10});
|
|
|
+ await rep.create({foo: 15});
|
|
|
+ const result = await rep.count({foo: {nin: [5, 10]}});
|
|
|
+ expect(result).to.be.eq(1);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "between" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ await rep.create({foo: 5});
|
|
|
+ await rep.create({foo: 10});
|
|
|
+ await rep.create({foo: 15});
|
|
|
+ await rep.create({foo: 20});
|
|
|
+ const result = await rep.count({foo: {between: [9, 16]}});
|
|
|
+ expect(result).to.be.eq(2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "exists" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ await rep.create({});
|
|
|
+ await rep.create({foo: undefined});
|
|
|
+ await rep.create({foo: null});
|
|
|
+ await rep.create({foo: 10});
|
|
|
+ const result1 = await rep.count({foo: {exists: true}});
|
|
|
+ expect(result1).to.be.eq(3);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "like" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ await rep.create({foo: 'lorem ipsum'});
|
|
|
+ await rep.create({foo: 'dolor sit amet'});
|
|
|
+ await rep.create({foo: 'DOLOR SIT AMET'});
|
|
|
+ await rep.create({foo: 'sit amet'});
|
|
|
+ const result = await rep.count({foo: {like: 'sit amet'}});
|
|
|
+ expect(result).to.be.eql(2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "nlike" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ await rep.create({foo: 'lorem ipsum'});
|
|
|
+ await rep.create({foo: 'dolor sit amet'});
|
|
|
+ await rep.create({foo: 'DOLOR SIT AMET'});
|
|
|
+ await rep.create({foo: 'sit amet'});
|
|
|
+ const result = await rep.count({foo: {nlike: 'sit amet'}});
|
|
|
+ expect(result).to.be.eql(2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "ilike" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ await rep.create({foo: 'lorem ipsum'});
|
|
|
+ await rep.create({foo: 'dolor sit amet'});
|
|
|
+ await rep.create({foo: 'DOLOR SIT AMET'});
|
|
|
+ await rep.create({foo: 'sit amet'});
|
|
|
+ const result = await rep.count({foo: {ilike: 'sit amet'}});
|
|
|
+ expect(result).to.be.eql(3);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "nilike" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ await rep.create({foo: 'lorem ipsum'});
|
|
|
+ await rep.create({foo: 'dolor sit amet'});
|
|
|
+ await rep.create({foo: 'DOLOR SIT AMET'});
|
|
|
+ await rep.create({foo: 'sit amet'});
|
|
|
+ const result = await rep.count({foo: {nilike: 'sit amet'}});
|
|
|
+ expect(result).to.be.eql(1);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "regexp" operator', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ await rep.create({foo: 'lorem ipsum'});
|
|
|
+ await rep.create({foo: 'dolor sit amet'});
|
|
|
+ await rep.create({foo: 'DOLOR SIT AMET'});
|
|
|
+ await rep.create({foo: 'sit amet'});
|
|
|
+ const result = await rep.count({foo: {regexp: 'sit am+'}});
|
|
|
+ expect(result).to.be.eql(2);
|
|
|
+ });
|
|
|
+
|
|
|
+ it('matches by the "regexp" operator with flags', async function () {
|
|
|
+ const schema = createSchema();
|
|
|
+ schema.defineModel({name: 'model', datasource: 'mongodb'});
|
|
|
+ const rep = schema.getRepository('model');
|
|
|
+ await rep.create({foo: 'lorem ipsum'});
|
|
|
+ await rep.create({foo: 'dolor sit amet'});
|
|
|
+ await rep.create({foo: 'DOLOR SIT AMET'});
|
|
|
+ await rep.create({foo: 'sit amet'});
|
|
|
+ const result = await rep.count({foo: {regexp: 'sit am+', flags: 'i'}});
|
|
|
+ expect(result).to.be.eql(3);
|
|
|
+ });
|
|
|
+ });
|
|
|
+ });
|
|
|
+});
|
e22m4u
2 years ago