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

package/test/references.ts

@@ -0,0 +1,162 @@
+/**
+ * @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.references'
+collNameConfig.entry = 'contents.references'
+collNameConfig.schema = 'content_types.references'
+
+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('# References', () => {
+
+  beforeAll(() => {
+    return Stack.connect().then((dbInstance) => {
+      db = dbInstance
+    })
+  })
+
+
+  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('.includeReferences()', () => {
+      return Stack.contentType('blog')
+        .entries()
+        .includeReferences()
+        .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('authors')
+            if (entry.authors instanceof Array) {
+              entry.authors.forEach((elem) => {
+                expect(elem).toHaveProperty('uid')
+                expect(elem).toHaveProperty('title')
+                expect(elem).not.toHaveProperty('_content_type_uid')
+              })
+            } else {
+              expect(entry.authors).toHaveProperty('uid')
+              expect(entry.authors).toHaveProperty('title')
+              expect(entry.authors).not.toHaveProperty('_content_type_uid')
+            }
+          })
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+
+    test('.queryOnReferences()', () => {
+      return Stack.contentType('blog')
+        .entries()
+        .queryReferences({'authors.uid': 'a10'})
+        .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('authors')
+            expect(entry.authors).toHaveProperty('uid')
+            expect(entry.authors.uid).toEqual('a10')
+          })
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+
+    test('.include()', () => {
+      return Stack.contentType('blog')
+        .entries()
+        .include(['authors'])
+        .find()
+        .then((result: any) => {
+          checkEntries(result)
+          expect(result.content_type_uid).toEqual('blog')
+          expect(result.entries).toHaveLength(5)
+          result.entries.forEach((entry) => {
+            if (entry.hasOwnProperty('self_reference')) {
+              expect(entry).toHaveProperty('self_reference')
+              expect(entry.self_reference instanceof Array).toBeTruthy()
+              entry.self_reference.forEach((ref) => {
+                expect(ref).toHaveProperty('_content_type_uid')
+                expect(ref).toHaveProperty('uid')
+              })
+            }
+
+            if (entry.hasOwnProperty('authors')) {
+              expect(entry).toHaveProperty('authors')
+              if (entry.authors instanceof Array) {
+                entry.authors.forEach((ref) => {
+                  expect(ref).toHaveProperty('title')
+                  expect(ref).toHaveProperty('uid')
+                  expect(ref).not.toHaveProperty('_content_type_uid')
+                })
+              } else {
+                expect(entry.authors).toHaveProperty('title')
+                expect(entry.authors).toHaveProperty('uid')
+              }
+            }
+          })
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+  })
+})
+

package/test/skip-limit.ts

@@ -0,0 +1,150 @@
+/**
+ * @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.skip_limit'
+collNameConfig.entry = 'contents.skip_limit'
+collNameConfig.schema = 'content_types.skip_limit'
+
+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
+let tempVariable
+
+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('# Conditional Operators', () => {
+
+  beforeAll(() => {
+    return Stack.connect().then((dbInstance) => {
+      db = dbInstance
+    })
+  })
+
+
+  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('.limit(1)', () => {
+      const limit = 1
+
+      return Stack.contentType('blog')
+        .entries()
+        .limit(limit)
+        .find()
+        .then((result: any) => {
+          checkEntries(result)
+          expect(result.content_type_uid).toEqual('blog')
+          expect(result.entries).toHaveLength(limit)
+          tempVariable = result.entries[0]
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+
+    test('.skip(1)', () => {
+      const skip = 1
+
+      return Stack.contentType('blog')
+      .entries()
+      .find()
+      .then((r1) => {
+
+        return Stack.contentType('blog')
+        .entries()
+        .skip(skip)
+        .find()
+        .then((result: any) => {
+          checkEntries(result)
+          expect(result).toHaveProperty('entries')
+          expect(result.content_type_uid).toEqual('blog')
+          expect(result.entries).toHaveLength((r1 as any).entries.length - skip)
+          result.entries.forEach((entry) => {
+            expect(entry).not.toMatchObject(tempVariable)
+          })
+        })
+      })
+      .catch((error) => {
+        expect(error).toBeNull()
+      })
+    })
+  })
+
+  describe('skip-limit combination', () => {
+    test('.skip(1) + .limit(1)', () => {
+      const skip = 1
+      const limit = 1
+
+      return Stack.contentType('blog')
+      .entries()
+      .find()
+      .then((r1) => {
+
+        return Stack.contentType('blog')
+        .entries()
+        .skip(skip)
+        .limit(limit)
+        .find()
+        .then((result: any) => {
+          checkEntries(result)
+          expect(result.content_type_uid).toEqual('blog')
+          expect(result.entries).toHaveLength(limit)
+          expect(result.entries[0]).not.toMatchObject((r1 as any).entries[0])
+        })
+      })
+      .catch((error) => {
+        expect(error).toBeNull()
+      })
+    })
+  })
+})
+

package/test/sorting.ts

@@ -0,0 +1,177 @@
+/**
+ * @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.sorting'
+collNameConfig.entry = 'contents.sorting'
+collNameConfig.schema = 'content_types.sorting'
+
+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('# Sorting', () => {
+
+  beforeAll(() => {
+    return Stack.connect().then((dbInstance) => {
+      db = dbInstance
+    })
+  })
+
+
+  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()
+  })
+
+  expect.extend({
+    compareValue(value, compareValue, operator, strict = false) {
+      // tslint:disable-next-line: one-variable-per-declaration
+      let pass, comparison
+      // if operator is true, value >= compareValue, else the opposite
+      if (operator) {
+        if (strict) {
+          comparison = ' > '
+          pass = value > compareValue
+        } else {
+          comparison = ' >= '
+          pass = value >= compareValue
+        }
+      } else {
+        if (strict) {
+          comparison = ' < '
+          pass = value < compareValue
+        } else {
+          comparison = ' <= '
+          pass = value <= compareValue
+        }
+      }
+
+      if (pass) {
+        return {
+          message: () =>
+            `expected ${value} not to be ${comparison} than ${compareValue}`,
+          pass: true,
+        }
+      } else {
+        return {
+          message: () =>
+          `expected ${value} to be ${comparison} than ${compareValue}`,
+          pass: false,
+        }
+      }
+    },
+  })
+
+  describe('on field', () => {
+    test('ascending', () => {
+      return Stack.contentType('blog')
+        .entries()
+        .ascending('no')
+        .find()
+        .then((result: any) => {
+          checkEntries(result)
+          expect(result.content_type_uid).toEqual('blog')
+          expect(result.entries).toHaveLength(5)
+          result.entries.forEach((entry, index) => {
+            if (index === (result.entries.length - 1)) {
+              index -= 1
+            }
+            (expect(entry.no) as any).compareValue(result.entries[index + 1].no, false)
+          })
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+
+    test('descending', () => {
+      return Stack.contentType('blog')
+        .entries()
+        .descending('no')
+        .find()
+        .then((result: any) => {
+          checkEntries(result)
+          expect(result.content_type_uid).toEqual('blog')
+          expect(result.entries).toHaveLength(5)
+          result.entries.forEach((entry, index) => {
+            if (index === (result.entries.length - 1)) {
+              index -= 1
+            }
+            (expect(entry.no) as any).compareValue(result.entries[index + 1].no, true)
+          })
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+  })
+
+  describe('without fields', () => {
+    test('expect natural .descending()', () => {
+      return Stack.contentType('blog')
+        .entries()
+        .find()
+        .then((result: any) => {
+          checkEntries(result)
+          expect(result.content_type_uid).toEqual('blog')
+          expect(result.entries).toHaveLength(5)
+          result.entries.forEach((entry, index) => {
+            if (index === (result.entries.length - 1)) {
+              index -= 1
+            }
+            (expect(entry.updated_at) as any).compareValue(result.entries[index + 1].updated_at, true)
+          })
+        }).catch((error) => {
+          expect(error).toBeNull()
+        })
+    })
+  })
+})
+

package/tslint.json

@@ -0,0 +1,45 @@
+{
+  "extends": "tslint:recommended",
+  "rules": {
+    "max-line-length": {
+      "options": [120]
+    },
+    "new-parens": true,
+    "no-arg": true,
+    "no-conditional-assignment": true,
+    "no-consecutive-blank-lines": false,
+    "no-console": {
+      "severity": "warning",
+      "options": [
+        "debug",
+        "info",
+        "log",
+        "time",
+        "timeEnd",
+        "trace"
+      ]
+    },
+    "no-empty-interface": true,
+    "only-arrow-functions": true,
+    "no-string-throw": true,
+    "triple-equals": true,
+    "eofline": true,
+    "indent": [true, "spaces", 2],
+    "max-file-line-count": [true, 2000],
+    "no-default-export": true,
+    "no-duplicate-imports": true,
+    "prefer-readonly": true,
+    "align": [true, "parameters", "statements"],
+    "class-name": true,
+    "import-spacing": true,
+    "interface-name": [true, "always-prefix"],
+    "newline-before-return": true,
+    "no-irregular-whitespace": true,
+    "no-trailing-whitespace": true,
+    "one-line": [true, "check-catch", "check-finally", "check-else"],
+    "one-variable-per-declaration": [true, "ignore-for-loop"],
+    "ordered-imports": true,
+    "semicolon": [true, "never"],
+    "quotemark": [true, "single", "avoid-escape", "avoid-template"]
+  }
+}

package/typings/config.d.ts

@@ -0,0 +1,42 @@
+/*!
+ * Contentstack DataSync Mongodb SDK
+ * Copyright (c) 2019 Contentstack LLC
+ * MIT Licensed
+ */
+export declare const config: {
+    contentStore: {
+        collection: {
+            asset: string;
+            entry: string;
+            schema: string;
+        };
+        dbName: string;
+        indexes: {
+            _content_type_uid: number;
+            locale: number;
+            uid: number;
+            updated_at: number;
+        };
+        internal: {
+            types: {
+                assets: string;
+                content_types: string;
+                references: string;
+            };
+        };
+        limit: number;
+        locale: string;
+        options: {
+            connectTimeoutMS: number;
+            noDelay: boolean;
+            useNewUrlParser: boolean;
+        };
+        projections: {
+            _content_type_uid: number;
+            _id: number;
+        };
+        referenceDepth: number;
+        skip: number;
+        url: string;
+    };
+};

package/typings/index.d.ts

@@ -0,0 +1,36 @@
+/*!
+ * Contentstack DataSync Mongodb SDK
+ * Copyright (c) 2019 Contentstack LLC
+ * MIT Licensed
+ */
+import { Stack } from './stack';
+/**
+ * @class Stack
+ * @description Initialize an instance of `Stack`
+ * @api public
+ * @example
+ * const Stack = Contentstack.Stack({
+ *  contentStore: {
+ *    baseDir: '../../dev-contents'
+ *  },
+ *  locales: [
+ *    {
+ *      code: 'en-us',
+ *      relative_url_prefix: '/'
+ *    }
+ *  ]
+ * })
+ *
+ * @returns {Stack} Returns Stack method, which's used to create an instance of Stack
+ */
+export declare class Contentstack {
+    /**
+     * @public
+     * @method Stack
+     * @summary Initialize Stack instance
+     * @param {object} config Stack config
+     * @param {object} db Existing db connection
+     * @returns {Stack} - Returns an instance of `Stack`
+     */
+    static Stack(config?: any, db?: any): Stack;
+}