Merge branch 'develop-151' into develop

Author: ehennum

.npmignore

@@ -0,0 +1,9 @@
+config-optic/
+examples/
+etc/
+test-basic/
+test-basic-proxy/
+test-complete/
+gulpfile.js
+.jshintrc
+jsdoc.json

gulpfile.js

@@ -13,11 +13,19 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+const path   = require('path');
 const gulp   = require('gulp');
 const jshint = require('gulp-jshint');
 const mocha  = require('gulp-mocha');
 const jsdoc  = require('gulp-jsdoc3');
 
+const { parallel, series } = gulp;
+
+const marklogic = require('./');
+const proxy = require('./lib/proxy-generator.js');
+const testproxy = require('./test-basic-proxy/testGenerator.js');
+const testconfig = require('./etc/test-config.js');
+const basicloader = require('./lib/basic-loader.js');
 
 function lint() {
   return gulp.src('lib/*')
@@ -36,13 +44,128 @@ function test() {
 }
 
 function doc() {
-  // TODO: clear the directory first
+  // TODO: clear the directory first - maybe by following this recipe:
+  // https://github.com/gulpjs/gulp/blob/master/docs/recipes/delete-files-folder.md
   const config = require('./jsdoc.json');
   return gulp.src(['./lib/*.js', 'README.md'])
     .pipe(jsdoc(config));
 }
 
+let testModulesClient = null;
+function getTestModulesClient() {
+  if (testModulesClient === null) {
+    const connectionParams = {
+      host:     testconfig.restEvaluatorConnection.host,
+      port:     testconfig.restEvaluatorConnection.port,
+      user:     testconfig.restEvaluatorConnection.user,
+      password: testconfig.restEvaluatorConnection.password,
+      authType: testconfig.restEvaluatorConnection.authType,
+      database: 'unittest-nodeapi-modules'
+    };
+    testModulesClient = marklogic.createDatabaseClient(connectionParams);
+  }
+  return testModulesClient;
+}
+function getTestDocumentPermissions() {
+  return [
+    {'role-name':'rest-reader', capabilities:['read', 'execute']},
+    {'role-name':'rest-writer', capabilities:['update']}
+  ];
+}
+
+function loadProxyTestInspector(callback) {
+  const testdir    = path.resolve('test-basic-proxy');
+  const modulesdir = path.resolve(testdir, 'ml-modules');
+  const filePath           = path.resolve(modulesdir, 'testInspector.sjs');
+  const databaseClient     = getTestModulesClient();
+  const documentDescriptor = {
+    uri:         '/dbf/test/testInspector.sjs',
+    contentType: 'application/vnd.marklogic-javascript',
+    permissions: getTestDocumentPermissions()
+  };
+  basicloader.loadFile(callback, {
+    filePath:           filePath,
+    databaseClient:     databaseClient,
+    documentDescriptor: documentDescriptor
+  });
+}
+
+function loadProxyTestData(callback) {
+  const testdir = path.resolve('test-basic-proxy');
+  const filePath           = path.resolve(testdir, 'testdef.json');
+  const databaseClient     = marklogic.createDatabaseClient(testconfig.restWriterConnection);
+  const documentDescriptor = {
+    uri:         '/dbf/test.json',
+    contentType: 'application/json'
+  };
+  basicloader.loadFile(callback, {
+    filePath:           filePath,
+    databaseClient:     databaseClient,
+    documentDescriptor: documentDescriptor
+  });
+}
+
+function loadProxyTestCases(callback) {
+  const databaseClient   = getTestModulesClient();
+  const documentMetadata = {
+    collections: ['/dbf/test/cases'],
+    permissions: getTestDocumentPermissions()
+  };
+  const uriPrefix     = '/dbf/test/';
+  const uriStartDepth = 4;
+  return gulp.src([
+    'test-basic-proxy/ml-modules/*/*/service.json',
+    'test-basic-proxy/ml-modules/*/*/*.api',
+    'test-basic-proxy/ml-modules/*/*/*.sjs',
+    'test-basic-proxy/ml-modules/*/*/*.mjs',
+    'test-basic-proxy/ml-modules/*/*/*.xqy'
+        ])
+      .pipe(basicloader.loadFileStream({
+        databaseClient:   databaseClient,
+        documentMetadata: documentMetadata,
+        uriPrefix:        uriPrefix,
+        uriStartDepth:    uriStartDepth
+        }));
+}
+function positiveProxyTests() {
+  return gulp.src('test-basic-proxy/ml-modules/positive/*')
+      .pipe(proxy.generate())
+      .pipe(gulp.dest('test-basic-proxy/lib/positive/'));
+}
+function negativeProxyTests() {
+  return gulp.src('test-basic-proxy/ml-modules/negative/*')
+      .pipe(proxy.generate())
+      .pipe(gulp.dest('test-basic-proxy/lib/negative/'));
+}
+function generatedProxyTests() {
+  return gulp.src('test-basic-proxy/ml-modules/generated/*')
+      .pipe(testproxy.generate())
+      .pipe(gulp.dest('test-basic-proxy/lib/generated/'));
+}
+function runProxyTests() {
+  return gulp.src(['test-basic-proxy/lib/*/*Test.js'])
+      .pipe(mocha({
+        reporter: 'spec',
+        globals: {
+          should: require('chai')
+        }
+      }));
+}
+function proxyDocTests() {
+  return gulp.src(['test-basic-proxy/lib/positive/DescribedBundle.js'])
+      .pipe(jsdoc({opts:{destination:'test-basic-proxy/doc'}}));
+}
+
 exports.doc = doc;
 exports.lint = lint;
+exports.loadProxyTests     = parallel(loadProxyTestInspector, loadProxyTestData, loadProxyTestCases);
+exports.generateProxyTests = parallel(positiveProxyTests, negativeProxyTests, generatedProxyTests);
+exports.generateProxyDocTests = proxyDocTests;
+exports.runProxyTests = runProxyTests;
+exports.proxyTests = series(
+    parallel(loadProxyTestInspector, loadProxyTestData, loadProxyTestCases),
+    parallel(positiveProxyTests, negativeProxyTests, generatedProxyTests),
+    proxyDocTests,
+    runProxyTests);
 exports.test = test;
 exports.default = lint;

lib/basic-loader.js

@@ -0,0 +1,122 @@
+/*
+ * Copyright 2019 MarkLogic Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const {Writable} = require('stream');
+
+const Vinyl = require('./optional.js').library('vinyl');
+
+function getDatabaseClient(loader, options) {
+  if (options === void 0 || options == null) {
+    throw new Error(`${loader} requires options`);
+  }
+
+  const databaseClient = options.databaseClient;
+  if (databaseClient === void 0 || databaseClient == null) {
+    throw new Error(`${loader} requires databaseClient option`);
+  }
+
+  return databaseClient;
+}
+
+function loadFile(callback, options) {
+  const databaseClient = getDatabaseClient('loadFile', options);
+
+  const filePath = options.filePath;
+  if (filePath === void 0 || filePath == null) {
+    throw new Error('loadFile requires the filePath for the source file');
+  }
+
+  const documentDescriptor = options.documentDescriptor;
+  if (documentDescriptor === void 0 || documentDescriptor == null) {
+    throw new Error(`loadFile requires fileDescriptor option`);
+  }
+
+  fs.readFile(filePath, 'utf8', (err, data) => {
+    if (err) {
+      callback(err);
+      return;
+    }
+    documentDescriptor.content = data;
+    databaseClient.documents.write(documentDescriptor)
+      .result(output => callback(), callback);
+  });
+}
+
+function loadFileStream(options) {
+  const databaseClient = getDatabaseClient('loadFileStream', options);
+
+  const documentMetadata = options.documentMetadata;
+  if (documentMetadata === void 0 || documentMetadata == null) {
+    throw new Error(`loadFileStream requires documentMetadata option`);
+  }
+
+  let uriPrefix = options.uriPrefix;
+  if (uriPrefix === void 0 || uriPrefix == null) {
+    uriPrefix = '/';
+  } else if (!uriPrefix.endsWith('/')) {
+    uriPrefix += '/';
+  }
+
+  let uriStartDepth = options.uriStartDepth;
+  if (uriStartDepth === void 0 || uriStartDepth == null) {
+    uriStartDepth = 2;
+  }
+  uriStartDepth += path.resolve().split(path.sep).length - 1;
+
+  const bufferMax = 100;
+  const batchSeed = [documentMetadata];
+  const fileBuffer = new Array(bufferMax);
+  let bufferNext = 0;
+  return new Writable({
+    objectMode: true,
+    write(file, encoding, callback) {
+      if (!Vinyl.isVinyl(file) || file.isDirectory() || file.path === void 0 || !(file.path.length > 0)) {
+        console.trace('not Vinyl file: '+file);
+        callback();
+        return;
+      }
+      fileBuffer[bufferNext++] = {
+        uri:     uriPrefix + file.path.split(path.sep).slice(uriStartDepth).join('/'),
+        content: file.contents
+      };
+      if (bufferNext < bufferMax) {
+        callback();
+        return;
+      }
+      databaseClient.documents.write(batchSeed.concat(fileBuffer))
+        .result(output => callback(), callback);
+      bufferNext = 0;
+    },
+    final(callback) {
+      if (bufferNext > 0) {
+        databaseClient.documents.write(batchSeed.concat(fileBuffer.slice(0, bufferNext)))
+            .result(output => callback(), callback);
+        bufferNext = 0;
+      } else {
+        callback();
+      }
+    }
+  });
+}
+
+module.exports = {
+  loadFile:       loadFile,
+  loadFileStream: loadFileStream
+};