Merge pull request #16 from zishone/dev

mongover@1.2.2
zishone · Apr 10, 2020 · ad912d0 · ad912d0
2 parents 58c3a6f + 9095850
commit ad912d0
Show file tree

Hide file tree

Showing 14 changed files with 72 additions and 68 deletions.
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "mongover",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "description": "A MongoDB Server Database Migration Tool",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

diff --git a/src/cli/commands/extract.ts b/src/cli/commands/extract.ts
@@ -17,11 +17,11 @@ const logger = getLogger(__filename);
 export async function extract(options: MongoverOptions): Promise<void> {
   try {
     logger.cli('Extracting Mongover Specification: %s', options.specPath);
-    const client = await connectServer(options.uri, { useNewUrlParser: true });
-    for (const dbName of options.dbs) {
+    const client = await connectServer(options.uri!, { useNewUrlParser: true });
+    for (const dbName of options.dbs!) {
       logger.cli('--- Extracting Database: %s', dbName);
       const db = client.db(dbName);
-      const databaseSpecPath = join(options.specPath, dbName);
+      const databaseSpecPath = join(options.specPath!, dbName);
       const collectionSpecPath = join(databaseSpecPath, 'collections');
       const dataPath = join(databaseSpecPath, 'data');
       ensureDirSync(dataPath);
@@ -31,7 +31,7 @@ export async function extract(options: MongoverOptions): Promise<void> {
         delete databaseSpecTemplate.collections;
       }
       const info = await db
-        .collection(options.infoCollection)
+        .collection(options.infoCollection!)
         .findOne({});
       if (info) {
         databaseSpecTemplate.version = info.version;
@@ -40,7 +40,7 @@ export async function extract(options: MongoverOptions): Promise<void> {
         .listCollections({ name: { $ne: options.infoCollection } })
         .toArray();
       for (const collectionInfo of collectionInfos) {
-        if (options.collections.length === 0 || options.collections.includes(collectionInfo.name)) {
+        if (options.collections!.length === 0 || options.collections!.includes(collectionInfo.name)) {
           logger.cli('----- Extracting Collection: %s', collectionInfo.name);
           const collection = db.collection(collectionInfo.name);
           collectionSpecTemplate.data.ignoreFields = [];
@@ -70,7 +70,7 @@ export async function extract(options: MongoverOptions): Promise<void> {
             databaseSpecTemplate.collections[collectionInfo.name] = collectionSpecTemplate;
           }
           if (options.export !== 'no') {
-            await exportData(collection, join(dataPath, collectionInfo.name), options.export, options.query);
+            await exportData(collection, join(dataPath, collectionInfo.name), options.export!, options.query);
           }
         }
       }

diff --git a/src/cli/commands/init.ts b/src/cli/commands/init.ts
@@ -17,20 +17,20 @@ const logger = getLogger(__filename);
 export async function init(options: MongoverOptions): Promise<void> {
   try {
     logger.cli('Initializing Mongover Specification: %s', options.specPath);
-    ensureDirSync(join(options.specPath, 'dbName', 'data'));
-    writeFileSync(join(options.specPath, 'dbName', 'data', 'collectionName.jsonl'), dataSample);
+    ensureDirSync(join(options.specPath!, 'dbName', 'data'));
+    writeFileSync(join(options.specPath!, 'dbName', 'data', 'collectionName.jsonl'), dataSample);
     switch (options.format) {
       case 'json':
-        writeJSONSync(join(options.specPath, 'dbName', 'db.spec.json'), {
+        writeJSONSync(join(options.specPath!, 'dbName', 'db.spec.json'), {
           ...databaseSpecTemplate,
           collections: { collectionName: collectionSpecTemplate },
         }, { spaces: 2 });
         break;
       case 'dir':
         delete databaseSpecTemplate.collections;
-        ensureDirSync(join(options.specPath, 'dbName', 'collections'));
-        writeJSONSync(join(options.specPath, 'dbName', 'db.spec.json'), databaseSpecTemplate, { spaces: 2 });
-        writeJSONSync(join(options.specPath, 'dbName', 'collections', 'collectionName.spec.json'), collectionSpecTemplate, { spaces: 2 });
+        ensureDirSync(join(options.specPath!, 'dbName', 'collections'));
+        writeJSONSync(join(options.specPath!, 'dbName', 'db.spec.json'), databaseSpecTemplate, { spaces: 2 });
+        writeJSONSync(join(options.specPath!, 'dbName', 'collections', 'collectionName.spec.json'), collectionSpecTemplate, { spaces: 2 });
         break;
       default:
         throw new Error(`Unrecognized format: ${options.format}.`);

diff --git a/src/core/apply.ts b/src/core/apply.ts
@@ -20,41 +20,42 @@ const logger = getLogger(__filename);
 
 export async function apply(options: MongoverOptions = parseOptions({})): Promise<void> {
   try {
-    logger.debug('Applying Mongover Specification: %s', options.specPath);
+    logger.info('Applying Mongover Specification: %s', options.specPath);
     options = parseOptions(options);
+    options.specPath! = join(process.cwd(), options.specPath!);
     const databases = [];
-    if (options.specPath.split('.').pop() === 'json') {
-      databases.push(getSpec(options.specPath));
-    } else if (lstatSync(options.specPath).isDirectory() && existsSync(join(options.specPath, 'db.spec.json'))) {
-      databases.push(getSpec(options.specPath));
+    if (options.specPath!.split('.').pop() === 'json') {
+      databases.push(getSpec(options.specPath!));
+    } else if (lstatSync(options.specPath!).isDirectory() && existsSync(join(options.specPath!, 'db.spec.json'))) {
+      databases.push(getSpec(options.specPath!));
     } else {
-      readdirSync(options.specPath)
-        .filter((dirent) => lstatSync(join(options.specPath, dirent)).isDirectory())
-        .forEach((dirent) => databases.push(getSpec(join(options.specPath, dirent))));
+      readdirSync(options.specPath!)
+        .filter((dirent) => lstatSync(join(options.specPath!, dirent)).isDirectory())
+        .forEach((dirent) => databases.push(getSpec(join(options.specPath!, dirent))));
     }
-    const client = await connectServer(options.uri, {
+    const client = await connectServer(options.uri!, {
       useNewUrlParser: true,
       useUnifiedTopology: true,
     });
     for (const database of databases) {
-      if (options.dbs.length === 0 || options.dbs.includes(database.name)) {
-        database.spec.alias = options.alias[options.dbs.indexOf(database.name)];
-        if (options.seedOnly) {
+      if (options.dbs!.length === 0 || options.dbs!.includes(database.name)) {
+        database.spec.alias = options.alias![options.dbs!.indexOf(database.name)];
+        if (options.seedOnly!) {
           database.spec.seedOnly = true;
         }
-        if (options.migrateForce) {
+        if (options.migrateForce!) {
           database.spec.migrateForce = true;
         }
         let versionCheck: any = {};
         if (database.spec.migrateForce) {
           versionCheck.higher = true;
         } else {
-          versionCheck = await compareVersion(client, database.name, options.infoCollection, database.spec);
+          versionCheck = await compareVersion(client, database.name, options.infoCollection!, database.spec);
         }
         if (versionCheck.higher) {
           const db = await structureDatabase(client, database.name, database.spec, versionCheck.version);
           for (const collectionName in database.spec.collections) {
-            if (options.collections.length === 0 || options.collections.includes(collectionName)) {
+            if (options.collections!.length === 0 || options.collections!.includes(collectionName)) {
               const collectionSpec = database.spec.collections[collectionName];
               const existingCollection = await db
                 .listCollections({ name: collectionName })
@@ -79,11 +80,11 @@ export async function apply(options: MongoverOptions = parseOptions({})): Promis
             }
           }
           if (!database.spec.seedOnly || !versionCheck.version || database.spec.migrateForce) {
-            database.spec.infoCollection = options.infoCollection;
+            database.spec.infoCollection = options.infoCollection!;
             await versionDatabase(db, database.spec);
           }
         } else {
-          logger.debug('Skipping Database: %s is not higher than %s', `${database.spec.alias || database.name}@${database.spec.version}`, versionCheck.version ? `${database.spec.alias || database.name}@${versionCheck.version}` : 'what is applied');
+          logger.info('Skipping Database: %s is not higher than %s', `${database.spec.alias || database.name}@${database.spec.version}`, versionCheck.version ? `${database.spec.alias || database.name}@${versionCheck.version}` : 'what is applied');
           logger.cli('--- Skipping Database: %s is not higher than %s', `${database.spec.alias || database.name}@${database.spec.version}`, versionCheck.version ? `${database.spec.alias || database.name}@${versionCheck.version}` : 'what is applied');
         }
       }

diff --git a/src/core/build-index.ts b/src/core/build-index.ts
@@ -14,7 +14,7 @@ export async function buildIndex(collection: Collection, indexSpec: IndexSpec):
       await collection.dropIndex(indexName);
     }
     try {
-      logger.debug('Building Index: %s', indexName);
+      logger.info('Building Index: %s', indexName);
       logger.cli('------- Building Index: %s', indexName);
       await collection.createIndex(indexSpec.keys, indexSpec.options);
     } catch (error) {

diff --git a/src/core/connect-server.ts b/src/core/connect-server.ts
@@ -10,7 +10,7 @@ export async function connectServer(uri: string, options: MongoClientOptions): P
   const loggableUri = uri.substring(0, uri.indexOf('://') + 3) +
     (uri.includes('@') ? uri.substring(uri.indexOf('@') + 1, uri.indexOf('?')) : uri.substring(uri.indexOf('://') + 3, uri.length));
   try {
-    logger.debug('Connecting to the Server: %s', loggableUri);
+    logger.info('Connecting to the Server: %s', loggableUri);
     logger.cli('- Connecting to the Server: %s', loggableUri);
     return await MongoClient.connect(uri, options);
   } catch (error) {

diff --git a/src/core/create-collection.ts b/src/core/create-collection.ts
@@ -21,7 +21,7 @@ export async function createCollection(db: Db, collectionName: string, collectio
     } else if (!existingCollection) {
       await db.createCollection(collectionName, collectionSpec.options);
     }
-    logger.debug('Creating Collection: %s', collectionName);
+    logger.info('Creating Collection: %s', collectionName);
     logger.cli('----- Creating Collection: %s', collectionName);
     logger.info('Created Collection: %s', collectionName);
     return collection;

diff --git a/src/core/import-data.ts b/src/core/import-data.ts
@@ -99,22 +99,25 @@ function processJsonl(collection: Collection, dataSpec: DataSpec, fileStream: In
 
 export async function importData(collection: Collection, dataSpec: DataSpec, dataPath: string): Promise<void> {
   try {
-    logger.debug('Importing Data: %s', dataPath.replace(process.cwd(), '.'));
-    logger.cli('------- Importing Data: %s', dataPath.replace(process.cwd(), '.'));
-    const fileType = dataPath.split('.').pop();
-    switch (fileType) {
-      case 'jsonl':
-        const fileStream = createInterface({ input: createReadStream(dataPath) });
-        await processJsonl(collection, dataSpec, fileStream);
-        break;
-      case 'json':
-      case 'js':
-      case 'ts':
-        const dataArr = require(dataPath);
-        await processDataArr(collection, dataSpec, dataArr);
-        break;
-      default:
-        throw new Error(`Unrecognized Export type: ${fileType}.`);
+    const filenameArr = dataPath.split('.');
+    const fileType = filenameArr.pop();
+    if (filenameArr.pop() !== 'd') {
+      logger.info('Importing Data: %s', dataPath.replace(process.cwd(), '.'));
+      logger.cli('------- Importing Data: %s', dataPath.replace(process.cwd(), '.'));
+      switch (fileType) {
+        case 'jsonl':
+          const fileStream = createInterface({ input: createReadStream(dataPath) });
+          await processJsonl(collection, dataSpec, fileStream);
+          break;
+        case 'json':
+        case 'js':
+        case 'ts':
+          const dataArr = require(dataPath);
+          await processDataArr(collection, dataSpec, dataArr);
+          break;
+        default:
+          throw new Error(`Unrecognized Export type: ${fileType}.`);
+      }
     }
   } catch (error) {
     logger.error('Error importing Data: %s', dataPath.replace(process.cwd(), '.'));

diff --git a/src/core/structure-database.ts b/src/core/structure-database.ts
@@ -15,7 +15,7 @@ export async function structureDatabase(client: MongoClient, databaseName: strin
       logger.cli('--- Dropping Database: %s%s', databaseSpec.alias || databaseName, appliedVersion ? `@${appliedVersion}` : '');
       await db.dropDatabase();
     }
-    logger.debug('Structuring Database: %s@%s', databaseName + (databaseSpec.alias ? ` as ${databaseSpec.alias}` : ''), databaseSpec.version);
+    logger.info('Structuring Database: %s@%s', databaseName + (databaseSpec.alias ? ` as ${databaseSpec.alias}` : ''), databaseSpec.version);
     logger.cli('--- Structuring Database: %s@%s', databaseName + (databaseSpec.alias ? ` as ${databaseSpec.alias}` : ''), databaseSpec.version);
     logger.info('Structured Database: %s@%s', databaseName + (databaseSpec.alias ? ` as ${databaseSpec.alias}` : ''), databaseSpec.version);
     return db;

diff --git a/src/core/version-database.ts b/src/core/version-database.ts
@@ -6,7 +6,7 @@ const logger = getLogger(__filename);
 
 export async function versionDatabase(db: Db, databaseSpec: DatabaseSpec): Promise<Db> {
   try {
-    logger.debug('Versioning Database: %s', `${db.databaseName}@${databaseSpec.version}`);
+    logger.info('Versioning Database: %s', `${db.databaseName}@${databaseSpec.version}`);
     logger.cli('--- Versioning Database: %s', `${db.databaseName}@${databaseSpec.version}`);
     const newMeta = { version: databaseSpec.version };
     const collection = db.collection(databaseSpec.infoCollection);

diff --git a/src/types/types.ts b/src/types/types.ts
@@ -22,17 +22,17 @@ export interface DataSpec {
 }
 
 export interface MongoverOptions {
-  specPath: string;
-  uri: string;
-  dbs: string[];
-  collections: string[];
-  alias: string[];
-  export: string;
-  format: string;
-  query: any;
-  seedOnly: boolean;
-  migrateForce: boolean;
-  infoCollection: string;
+  specPath?: string;
+  uri?: string;
+  dbs?: string[];
+  collections?: string[];
+  alias?: string[];
+  export?: string;
+  format?: string;
+  query?: any;
+  seedOnly?: boolean;
+  migrateForce?: boolean;
+  infoCollection?: string;
 }
 
 export interface DatabaseSpec {

diff --git a/src/utils/constants.ts b/src/utils/constants.ts
@@ -47,7 +47,7 @@ Usage:
 `.trim();
 
 export const mongoverOptionsDefaults: MongoverOptions = {
-  specPath: join(process.cwd(), 'mongover'),
+  specPath: 'database',
   uri: 'mongodb://127.0.0.1:27017/',
   dbs: [],
   alias: [],

diff --git a/src/utils/parse-options.ts b/src/utils/parse-options.ts
@@ -6,10 +6,10 @@ import { mongoverOptionsDefaults } from './constants';
 export function parseOptions(args: any): MongoverOptions {
   try {
     const mongoverOptions: MongoverOptions = mongoverOptionsDefaults;
-    if (args.specPath && args.specPath !== mongoverOptions.specPath) {
-      mongoverOptions.specPath = join(process.cwd(), args.specPath);
+    if (args.specPath) {
+      mongoverOptions.specPath = args.specPath;
     } else if (args._ && args._[0]) {
-      mongoverOptions.specPath = join(process.cwd(), args._[0]);
+      mongoverOptions.specPath = args._[0];
     }
     if (args.uri) {
       mongoverOptions.uri = args.uri;
@@ -53,7 +53,7 @@ export function parseOptions(args: any): MongoverOptions {
       mongoverOptions.infoCollection = args.infoCollection;
     }
 
-    if (mongoverOptions.alias.length !== mongoverOptions.dbs.length) {
+    if (mongoverOptions.alias!.length !== mongoverOptions.dbs!.length) {
       throw new Error('-d | --dbs and -a | --alias should have the same length.');
     }
     switch (mongoverOptions.format) {