@contentstack/datasync-mongodb-sdk 1.0.9-beta.1

package/test/expressions.ts

@@ -0,0 +1,108 @@
+/**
+ * @description Test contentstack-mongodb-sdk basic methods
+ */
+
+import { cloneDeep } from 'lodash'
+import { Contentstack } from '../src'
+import { config } from './config'
+import { assets } from './data/assets'
+import { entries as authors } from './data/author'
+import { entries as blogs } from './data/blog'
+import { entries as categories } from './data/category'
+import { content_types } from './data/content_types'
+
+const scriptConfig = cloneDeep(config)
+const collNameConfig: any = scriptConfig.contentStore.collection
+collNameConfig.asset = 'contents.expressions'
+collNameConfig.entry = 'contents.expressions'
+collNameConfig.schema = 'content_types.expressions'
+
+const Stack = Contentstack.Stack(scriptConfig)
+const collection = cloneDeep(collNameConfig)
+
+collection.asset = `en-us.${collNameConfig.asset}`
+collection.entry = `en-us.${collNameConfig.entry}`
+collection.schema = `en-us.${collNameConfig.schema}`
+
+let db
+
+function fnWhere() {
+  return (this.no === 1)
+}
+
+const checkEntries = (result: any) => {
+  expect(result).toHaveProperty('entries')
+  expect(result).toHaveProperty('locale')
+  expect(result).toHaveProperty('content_type_uid')
+  expect(result.locale).toEqual('en-us')
+  expect(result.entries instanceof Array).toBeTruthy()
+  result.entries.forEach((item) => {
+    expect(item).not.toHaveProperty('_content_type_uid')
+  })
+}
+
+describe('# Expressional Operators', () => {
+
+  beforeAll(() => {
+    return Stack.connect().then((dbInstance) => {
+      db = dbInstance
+
+      return
+    })
+  })
+
+  beforeAll(async () => {
+    await db.collection(collection.entry).insertMany(authors)
+    await db.collection(collection.entry).insertMany(blogs)
+    await db.collection(collection.entry).insertMany(categories)
+    await db.collection(collection.asset).insertMany(assets)
+    await db.collection(collection.schema).insertMany(content_types)
+
+    return
+  })
+
+  afterAll(async () => {
+    await db.collection(collection.entry).drop()
+    // await db.collection(collection.asset).drop()
+    await db.collection(collection.schema).drop()
+
+    return Stack.close()
+  })
+
+  describe('basic', () => {
+    test('.where()', () => {
+      return Stack.contentType('blog')
+        .entries()
+        .where(fnWhere)
+        .find()
+        .then((result: any) => {
+          checkEntries(result)
+          expect(result.content_type_uid).toEqual('blog')
+          result.entries.forEach((entry) => {
+            expect(entry).toHaveProperty('no')
+            expect(entry.no).toEqual(1)
+          })
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+
+    test('.regex()', () => {
+      return Stack.contentType('blog')
+        .entries()
+        .regex('title', '/^Blog Two$/', 'i')
+        .find()
+        .then((result: any) => {
+          checkEntries(result)
+          expect(result.content_type_uid).toEqual('blog')
+          result.entries.forEach((entry) => {
+            expect(entry).toHaveProperty('title')
+            expect(entry.title).toMatch(/^Blog Two$/)
+          })
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+  })
+})
+

package/test/include-exclude.ts

@@ -0,0 +1,176 @@
+/**
+ * @description Test contentstack-mongodb-sdk basic methods
+ */
+
+import Debug from 'debug'
+import { cloneDeep } from 'lodash'
+import { Contentstack } from '../src'
+import { config } from './config'
+import { assets } from './data/assets'
+import { entries as authors } from './data/author'
+import { entries as blogs } from './data/blog'
+import { entries as categories } from './data/category'
+import { content_types } from './data/content_types'
+
+const scriptConfig = cloneDeep(config)
+const collNameConfig: any = scriptConfig.contentStore.collection
+collNameConfig.asset = 'contents.include_exclude'
+collNameConfig.entry = 'contents.include_exclude'
+collNameConfig.schema = 'content_types.include_exclude'
+
+const Stack = Contentstack.Stack(scriptConfig)
+const collection = cloneDeep(collNameConfig)
+const debug = new Debug('test:include-exclude')
+collection.asset = `en-us.${collNameConfig.asset}`
+collection.entry = `en-us.${collNameConfig.entry}`
+collection.schema = `en-us.${collNameConfig.schema}`
+
+let db
+
+const itemPropertyChecks = (result) => {
+  expect(result).toHaveProperty('entries')
+  expect(result).toHaveProperty('locale')
+  expect(result).toHaveProperty('content_type_uid')
+  expect(result.locale).toEqual('en-us')
+  result.entries.forEach((item) => {
+    expect(item).not.toHaveProperty('_content_type_uid')
+  })
+}
+
+describe('# Include Exclude', () => {
+
+  beforeAll(() => {
+    return Stack.connect().then((dbInstance) => {
+      db = dbInstance
+      debug('Stack connected successfully!')
+
+      return
+    })
+  })
+
+  beforeAll(async () => {
+    await db.collection(collection.entry).insertMany(authors)
+    await db.collection(collection.entry).insertMany(blogs)
+    await db.collection(collection.entry).insertMany(categories)
+    await db.collection(collection.asset).insertMany(assets)
+    await db.collection(collection.schema).insertMany(content_types)
+    debug('Data populated..!')
+
+    return
+  })
+
+  afterAll(async () => {
+    await db.collection(collection.entry).drop()
+    // await db.collection(collection.asset).drop()
+    await db.collection(collection.schema).drop()
+    debug('Collections dropped..!')
+
+    return Stack.close()
+  })
+
+  describe('basic inclusion', () => {
+    test('1 .includeCount()', () => {
+      return Stack.contentType('blog')
+        .entries()
+        .includeCount()
+        .find()
+        .then((result: any) => {
+          debug(`# include-exclude: .includeCount() result\n${JSON.stringify(result)}`)
+          itemPropertyChecks(result)
+          expect(result.content_type_uid).toEqual('blog')
+          expect(result.entries).toHaveLength(5)
+          expect(result).toHaveProperty('count')
+          expect(result.count).toEqual(5)
+          result.entries.forEach((entry) => {
+            expect(entry).toHaveProperty('no')
+          })
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+
+    test('2 .includeSchema()', () => {
+      return Stack.contentType('blog')
+        .entries()
+        .includeSchema()
+        .find()
+        .then((result: any) => {
+          itemPropertyChecks(result)
+          expect(result.content_type_uid).toEqual('blog')
+          expect(result.entries).toHaveLength(5)
+          expect(result).toHaveProperty('content_type')
+          expect(result.content_type).toHaveProperty('uid')
+          expect(result.content_type).toHaveProperty('title')
+          expect(result.content_type).toHaveProperty('schema')
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+
+    test('3 .excludeReferences()', () => {
+      return Stack.contentType('blog')
+        .entries()
+        .excludeReferences()
+        .find()
+        .then((result: any) => {
+          itemPropertyChecks(result)
+          expect(result.content_type_uid).toEqual('blog')
+          expect(result.entries).toHaveLength(5)
+          result.entries.forEach((entry) => {
+            if (entry.hasOwnProperty('authors')) {
+              if (entry.authors instanceof Array) {
+                entry.authors.forEach((ref) => {
+                  expect(ref).toHaveProperty('_content_type_uid')
+                  expect(ref).toHaveProperty('uid')
+                })
+              } else {
+                expect(entry.authors).toHaveProperty('_content_type_uid')
+                expect(entry.authors).toHaveProperty('uid')
+              }
+            }
+          })
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+  })
+
+  describe('combination of include-exclude', () => {
+    test('1 .includeCount() + .includeSchema() + .excludeReferences()', () => {
+      return Stack.contentType('blog')
+        .entries()
+        .includeCount()
+        .includeSchema()
+        .excludeReferences()
+        .find()
+        .then((result: any) => {
+          itemPropertyChecks(result)
+          expect(result.content_type_uid).toEqual('blog')
+          expect(result.entries).toHaveLength(5)
+          expect(result).toHaveProperty('count')
+          expect(result.count).toEqual(5)
+          expect(result).toHaveProperty('content_type')
+          expect(result.content_type).toHaveProperty('uid')
+          expect(result.content_type).toHaveProperty('title')
+          expect(result.content_type).toHaveProperty('schema')
+          result.entries.forEach((entry) => {
+            if (entry.authors && entry.authors instanceof Array) {
+              entry.authors.forEach((ref) => {
+                expect(ref).toHaveProperty('_content_type_uid')
+                expect(ref).toHaveProperty('uid')
+                expect(ref._content_type_uid).toEqual('author')
+              })
+            } else {
+              expect(entry.authors).toHaveProperty('_content_type_uid')
+              expect(entry.authors).toHaveProperty('uid')
+              expect(entry.authors._content_type_uid).toEqual('author')
+            }
+            expect(entry).toHaveProperty('no')
+          })
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+  })
+})
+

package/test/logical-operators.ts

@@ -0,0 +1,140 @@
+/**
+ * @description Test contentstack-mongodb-sdk basic methods
+ */
+
+import { cloneDeep } from 'lodash'
+import { Contentstack } from '../src'
+import { config } from './config'
+import { assets } from './data/assets'
+import { entries as authors } from './data/author'
+import { entries as blogs } from './data/blog'
+import { entries as categories } from './data/category'
+import { content_types } from './data/content_types'
+
+const scriptConfig = cloneDeep(config)
+const collNameConfig: any = scriptConfig.contentStore.collection
+collNameConfig.asset = 'contents.logical_operators'
+collNameConfig.entry = 'contents.logical_operators'
+collNameConfig.schema = 'content_types.logical_operators'
+
+const Stack = Contentstack.Stack(scriptConfig)
+const collection = cloneDeep(collNameConfig)
+
+collection.asset = `en-us.${collNameConfig.asset}`
+collection.entry = `en-us.${collNameConfig.entry}`
+collection.schema = `en-us.${collNameConfig.schema}`
+
+let db
+
+const itemPropertyChecks = (result) => {
+  expect(result).toHaveProperty('entries')
+  expect(result).toHaveProperty('locale')
+  expect(result).toHaveProperty('content_type_uid')
+  expect(result.locale).toEqual('en-us')
+  if (result.entries instanceof Array) {
+    result.entries.forEach((item) => {
+      expect(item).not.toHaveProperty('_content_type_uid')
+    })
+  }
+}
+
+describe('# Logical Operator Querying', () => {
+
+  beforeAll(() => {
+    return Stack.connect().then((dbInstance) => {
+      db = dbInstance
+
+      return
+    })
+  })
+
+  beforeAll(async () => {
+    await db.collection(collection.entry).insertMany(authors)
+    await db.collection(collection.entry).insertMany(blogs)
+    await db.collection(collection.entry).insertMany(categories)
+    await db.collection(collection.asset).insertMany(assets)
+    await db.collection(collection.schema).insertMany(content_types)
+
+    return
+  })
+
+  afterAll(async () => {
+    await db.collection(collection.entry).drop()
+    // await db.collection(collection.asset).drop()
+    await db.collection(collection.schema).drop()
+
+    return Stack.close()
+  })
+
+  describe('on: non pre-existing operator', () => {
+    test('.and()', () => {
+      return Stack.contentType('blog')
+        .entries()
+        .and([{_content_type_uid: 'blog'}, {no: 1}])
+        .find()
+        .then((result: any) => {
+          itemPropertyChecks(result)
+          expect(result.content_type_uid).toEqual('blog')
+          expect(result.entries).toHaveLength(1)
+          result.entries.forEach((entry) => {
+            expect(entry).toHaveProperty('no')
+            expect(entry.no).toEqual(1)
+          })
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+
+    test('.or()', () => {
+      return Stack.contentType('blog')
+        .entries()
+        .or([{_content_type_uid: 'blogs'}, {no: 1}])
+        .find()
+        .then((result: any) => {
+          itemPropertyChecks(result)
+          expect(result.content_type_uid).toEqual('blog')
+          expect(result.entries).toHaveLength(1)
+          result.entries.forEach((entry) => {
+            expect(entry).toHaveProperty('no')
+            expect(entry.no).toEqual(1)
+          })
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+
+  })
+
+  describe('on: pre-existing operator', () => {
+    test('.and()', () => {
+      return Stack.contentType('blog')
+        .entries()
+        .and([{no: 1}])
+        .and([{_content_type_uid: 'blogs'}])
+        .find()
+        .then((result: any) => {
+          itemPropertyChecks(result)
+          expect(result.content_type_uid).toEqual('blog')
+          expect(result.entries).toHaveLength(0)
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+
+    test('.or()', () => {
+      return Stack.contentType('blog')
+        .entries()
+        .or([{no: 1}])
+        .or([{_content_type_uid: 'blogs'}])
+        .find()
+        .then((result: any) => {
+          itemPropertyChecks(result)
+          expect(result.content_type_uid).toEqual('blog')
+          expect(result.entries).toHaveLength(0)
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+  })
+})
+

package/test/projections.ts

@@ -0,0 +1,109 @@
+/**
+ * @description Test contentstack-mongodb-sdk basic methods
+ */
+
+import { cloneDeep } from 'lodash'
+import { Contentstack } from '../src'
+import { config } from './config'
+import { assets } from './data/assets'
+import { entries as authors } from './data/author'
+import { entries as blogs } from './data/blog'
+import { entries as categories } from './data/category'
+import { content_types } from './data/content_types'
+
+const scriptConfig = cloneDeep(config)
+const collNameConfig: any = scriptConfig.contentStore.collection
+collNameConfig.asset = 'contents.projections'
+collNameConfig.entry = 'contents.projections'
+collNameConfig.schema = 'content_types.projections'
+
+const Stack = Contentstack.Stack(scriptConfig)
+const collection = cloneDeep(collNameConfig)
+
+collection.asset = `en-us.${collNameConfig.asset}`
+collection.entry = `en-us.${collNameConfig.entry}`
+collection.schema = `en-us.${collNameConfig.schema}`
+
+let db
+
+const checkEntries = (result: any) => {
+  expect(result).toHaveProperty('entries')
+  expect(result).toHaveProperty('locale')
+  expect(result).toHaveProperty('content_type_uid')
+  expect(result.locale).toEqual('en-us')
+  expect(result.entries instanceof Array).toBeTruthy()
+  result.entries.forEach((item) => {
+    expect(item).not.toHaveProperty('_content_type_uid')
+  })
+}
+
+describe('# Projections', () => {
+
+  beforeAll(() => {
+    return Stack.connect().then((dbInstance) => {
+      db = dbInstance
+
+      return
+    })
+  })
+
+  beforeAll(async () => {
+    await db.collection(collection.entry).insertMany(authors)
+    await db.collection(collection.entry).insertMany(blogs)
+    await db.collection(collection.entry).insertMany(categories)
+    await db.collection(collection.asset).insertMany(assets)
+    await db.collection(collection.schema).insertMany(content_types)
+
+    return
+  })
+
+  afterAll(async () => {
+    await db.collection(collection.entry).drop()
+    // await db.collection(collection.asset).drop()
+    await db.collection(collection.schema).drop()
+
+    return Stack.close()
+  })
+
+  describe('basic', () => {
+    test('.only()', () => {
+      return Stack.contentType('blog')
+        .entries()
+        .only(['uid', 'title', '_id'])
+        .find()
+        .then((result: any) => {
+          checkEntries(result)
+          expect(result.content_type_uid).toEqual('blog')
+          expect(result.entries).toHaveLength(5)
+          result.entries.forEach((entry) => {
+            expect(entry).toHaveProperty('uid')
+            expect(entry).toHaveProperty('title')
+            expect(entry).toHaveProperty('_id')
+            expect(Object.keys(entry)).toHaveLength(3)
+          })
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+
+    test('.except()', () => {
+      return Stack.contentType('blog')
+        .entries()
+        .except(['uid', 'title'])
+        .find()
+        .then((result: any) => {
+          checkEntries(result)
+          expect(result).toHaveProperty('entries')
+          expect(result.content_type_uid).toEqual('blog')
+          expect(result.entries).toHaveLength(5)
+          result.entries.forEach((entry) => {
+            expect(entry).not.toHaveProperty('uid')
+            expect(entry).not.toHaveProperty('title')
+            expect(entry).not.toHaveProperty('_id')
+          })
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+  })
+})

package/test/queries.ts

@@ -0,0 +1,143 @@
+/**
+ * @description Test contentstack-mongodb-sdk basic methods
+ */
+
+import { cloneDeep } from 'lodash'
+import { Contentstack } from '../src'
+import { config } from './config'
+import { assets } from './data/assets'
+import { entries as authors } from './data/author'
+import { entries as blogs } from './data/blog'
+import { entries as categories } from './data/category'
+import { content_types } from './data/content_types'
+
+const scriptConfig = cloneDeep(config)
+const collNameConfig: any = scriptConfig.contentStore.collection
+collNameConfig.asset = 'contents.query_filters'
+collNameConfig.entry = 'contents.query_filters'
+collNameConfig.schema = 'content_types.query_filters'
+
+const Stack = Contentstack.Stack(scriptConfig)
+const collection = cloneDeep(collNameConfig)
+
+collection.asset = `en-us.${collNameConfig.asset}`
+collection.entry = `en-us.${collNameConfig.entry}`
+collection.schema = `en-us.${collNameConfig.schema}`
+
+let db
+
+const checkEntries = (result: any) => {
+  expect(result).toHaveProperty('entries')
+  expect(result).toHaveProperty('locale')
+  expect(result).toHaveProperty('content_type_uid')
+  expect(result.locale).toEqual('en-us')
+  expect(result.entries instanceof Array).toBeTruthy()
+  result.entries.forEach((item) => {
+    expect(item).not.toHaveProperty('_content_type_uid')
+  })
+}
+
+describe('# Querying', () => {
+
+  beforeAll(() => {
+    return Stack.connect().then((dbInstance) => {
+      db = dbInstance
+
+      return
+    })
+  })
+
+  beforeAll(async () => {
+    await db.collection(collection.entry).insertMany(authors)
+    await db.collection(collection.entry).insertMany(blogs)
+    await db.collection(collection.entry).insertMany(categories)
+    await db.collection(collection.asset).insertMany(assets)
+    await db.collection(collection.schema).insertMany(content_types)
+
+    return
+  })
+
+  afterAll(async () => {
+    await db.collection(collection.entry).drop()
+    // await db.collection(collection.asset).drop()
+    await db.collection(collection.schema).drop()
+
+    return Stack.close()
+  })
+
+  describe('basic querying', () => {
+    test('.query $and', () => {
+      return Stack.contentType('blog')
+        .entries()
+        .query({$and: [{_content_type_uid: 'blog'}, {no: 1}]})
+        .find()
+        .then((result: any) => {
+          checkEntries(result)
+          expect(result.content_type_uid).toEqual('blog')
+          expect(result.entries).toHaveLength(1)
+          result.entries.forEach((entry) => {
+            expect(entry).toHaveProperty('no')
+            expect(entry.no).toEqual(1)
+          })
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+
+    test('.query $or', () => {
+      return Stack.contentType('blog')
+        .entries()
+        .query({$or: [{content_type_uid: 'blogs'}, {no: 1}]})
+        .find()
+        .then((result: any) => {
+          checkEntries(result)
+          expect(result.content_type_uid).toEqual('blog')
+          expect(result.entries).toHaveLength(1)
+          result.entries.forEach((entry) => {
+            expect(entry).toHaveProperty('no')
+            expect(entry.no).toEqual(1)
+          })
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+
+    test('.tags()', () => {
+      return Stack.contentType('blog')
+        .entries()
+        .tags(['last'])
+        .find()
+        .then((result: any) => {
+          checkEntries(result)
+          expect(result.content_type_uid).toEqual('blog')
+          expect(result.entries).toHaveLength(1)
+          result.entries.forEach((entry) => {
+            expect(entry).toHaveProperty('tags')
+            expect(entry.tags).toContain('last')
+          })
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+
+    test('.query + .tags()', () => {
+      return Stack.contentType('blog')
+        .entries()
+        .query({$or: [{content_type_uid: 'blogs'}, {tags: {$exists: true}}]})
+        .tags(['last'])
+        .find()
+        .then((result: any) => {
+          checkEntries(result)
+          expect(result.content_type_uid).toEqual('blog')
+          expect(result.entries).toHaveLength(1)
+          result.entries.forEach((entry) => {
+            expect(entry).toHaveProperty('tags')
+            expect(entry.tags).toContain('last')
+          })
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+  })
+})
+