@opentermsarchive/engine 15.3.1 → 16.0.1

package/bin/ota-dataset.js

@@ -11,18 +11,16 @@ import logger from '../src/logger/index.js';
 
 program
   .name('ota dataset')
-  .description('Export the versions dataset into a ZIP file and optionally publish it to GitHub releases, GitLab releases, or data.gouv.fr')
+  .description('Export the versions dataset into a ZIP file stored locally and optionally publish it to GitHub releases, GitLab releases, or data.gouv.fr')
   .option('-f, --file <filename>', 'file name of the generated dataset')
   .option('-p, --publish', 'publish dataset. Supports GitHub releases (OTA_ENGINE_GITHUB_TOKEN), GitLab releases (OTA_ENGINE_GITLAB_TOKEN), or data.gouv.fr (OTA_ENGINE_DATAGOUV_API_KEY + config)')
-  .option('-r, --remove-local-copy', 'remove local copy of dataset after publishing. Works only in combination with --publish option')
   .option('--schedule', 'schedule automatic dataset generation');
 
-const { schedule, publish, removeLocalCopy, file: fileName } = program.parse().opts();
+const { schedule, publish, file: fileName } = program.parse().opts();
 
 const options = {
   fileName,
   shouldPublish: publish,
-  shouldRemoveLocalCopy: removeLocalCopy,
 };
 
 if (!schedule) {
@@ -34,5 +32,5 @@ if (!schedule) {
   logger.info('The scheduler is running…');
   logger.info(`Dataset will be published ${humanReadableSchedule.toLowerCase()} in the timezone of this machine`);
 
-  new Cron(config.get('@opentermsarchive/engine.dataset.publishingSchedule'), () => release(options)); // eslint-disable-line no-new
+  new Cron(trackingSchedule, { catch: error => logger.error(`Dataset release failed: ${error.stack}`) }, () => release(options)); // eslint-disable-line no-new
 }

package/bin/ota.js

@@ -14,6 +14,6 @@ program
   .command('apply-technical-upgrades', 'Apply technical upgrades by generating new versions from the latest snapshots using updated declarations, engine logic, or dependencies')
   .command('validate', 'Run a series of tests to check the validity of terms declarations')
   .command('lint', 'Check format and stylistic errors in declarations and auto fix them')
-  .command('dataset', 'Export the versions dataset into a ZIP file and optionally publish it to GitHub releases')
+  .command('dataset', 'Export the versions dataset into a ZIP file stored locally and optionally publish it to GitHub releases, GitLab releases, or data.gouv.fr')
   .command('serve', 'Start the collection metadata API server')
   .parse(process.argv);

package/config/default.json

@@ -46,7 +46,8 @@
       "timestampPrefix": true
     },
     "dataset": {
-      "publishingSchedule": "30 8 * * MON"
+      "publishingSchedule": "30 8 * * MON",
+      "storagePath": "./data/datasets"
     },
     "collection-api": {
       "feed": {

package/config/test.json

@@ -43,7 +43,9 @@
     },
     "dataset": {
       "title": "sandbox",
-      "versionsRepositoryURL": "https://github.com/OpenTermsArchive/sandbox-versions"
+      "versionsRepositoryURL": "https://github.com/OpenTermsArchive/sandbox-versions",
+      "apiBaseURL": "https://gitlab.example.test/api/v4",
+      "storagePath": "./test/data/datasets"
     },
     "collection-api": {
       "port": 3000,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opentermsarchive/engine",
-  "version": "15.3.1",
+  "version": "16.0.1",
   "description": "Tracks and makes visible changes to the terms of online services",
   "homepage": "https://opentermsarchive.org",
   "bugs": {
@@ -34,7 +34,7 @@
   "scripts": {
     "commit-messages:lint": "commitlint --from=main --to=HEAD",
     "dataset:generate": "node bin/ota.js dataset",
-    "dataset:release": "node bin/ota.js dataset --publish --remove-local-copy",
+    "dataset:release": "node bin/ota.js dataset --publish",
     "dataset:scheduler": "npm run dataset:release -- --schedule",
     "declarations:lint": "node bin/ota.js lint",
     "declarations:validate": "node bin/ota.js validate declarations",

package/scripts/dataset/assets/README.template.js

@@ -1,5 +1,7 @@
 import config from 'config';
 
+import * as license from '../../../src/dataset/license.js';
+
 const LOCALE = 'en-EN';
 const DATE_OPTIONS = { year: 'numeric', month: 'long', day: 'numeric' };
 
@@ -60,6 +62,6 @@ This dataset represents each version of a document as a separate [Markdown](http
 
 ### License
 
-This dataset is made available under an [Open Database (OdBL) License](https://opendatacommons.org/licenses/odbl/1.0/) by Open Terms Archive Contributors.
+This dataset is made available under an [${license.DISPLAY_NAME}](${license.INFO_URL}) by Open Terms Archive Contributors.
 `;
 }

package/scripts/dataset/export/index.js

@@ -1,11 +1,14 @@
+import { createHash } from 'crypto';
 import fsApi from 'fs';
 import path from 'path';
+import { pipeline } from 'stream/promises';
 import { fileURLToPath } from 'url';
 
 import archiver from 'archiver';
 import config from 'config';
 
 import RepositoryFactory from '../../../src/archivist/recorder/repositories/factory.js';
+import { TEMPORARY_SUFFIX } from '../../../src/dataset/storage.js';
 import * as renamer from '../../utils/renamer/index.js';
 import readme from '../assets/README.template.js';
 import logger from '../logger/index.js';
@@ -19,83 +22,96 @@ const ARCHIVE_FORMAT = 'zip'; // for supported formats, see https://www.archiver
 export default async function generate({ archivePath, releaseDate }) {
   const versionsRepository = await RepositoryFactory.create(config.get('@opentermsarchive/engine.recorder.versions.storage')).initialize();
 
-  const archive = await initializeArchive(archivePath);
+  const temporaryArchivePath = `${archivePath}${TEMPORARY_SUFFIX}`;
+  const archive = await initializeArchive(temporaryArchivePath, path.basename(archivePath, path.extname(archivePath)));
 
-  await renamer.loadRules();
+  try {
+    await renamer.loadRules();
 
-  const services = new Set();
-  let firstVersionDate = new Date();
-  let lastVersionDate = new Date(0);
+    const services = new Set();
+    const terms = new Set();
+    let firstVersionDate = new Date();
+    let lastVersionDate = new Date(0);
 
-  let index = 1;
+    let versionsCount = 0;
 
-  for await (const version of versionsRepository.iterate()) {
-    const { content, fetchDate } = version;
+    for await (const version of versionsRepository.iterate()) {
+      const { content, fetchDate } = version;
 
-    for (const { serviceId, termsType } of renamer.applyRules(version.serviceId, version.termsType)) {
-      if (firstVersionDate > fetchDate) {
-        firstVersionDate = fetchDate;
-      }
+      for (const { serviceId, termsType } of renamer.applyRules(version.serviceId, version.termsType)) {
+        if (firstVersionDate > fetchDate) {
+          firstVersionDate = fetchDate;
+        }
 
-      if (fetchDate > lastVersionDate) {
-        lastVersionDate = fetchDate;
-      }
+        if (fetchDate > lastVersionDate) {
+          lastVersionDate = fetchDate;
+        }
 
-      services.add(serviceId);
+        services.add(serviceId);
+        terms.add(`${serviceId}/${termsType}`);
+        versionsCount++;
 
-      const versionPath = generateVersionPath({ serviceId, termsType, fetchDate });
+        const versionPath = generateVersionPath({ serviceId, termsType, fetchDate });
 
-      logger.info({ message: versionPath, counter: index, hash: version.id });
+        logger.info({ message: versionPath, counter: versionsCount, hash: version.id });
 
-      archive.stream.append(
-        content,
-        { name: `${archive.basename}/${versionPath}` },
-      );
-      index++;
+        archive.stream.append(
+          content,
+          { name: `${archive.basename}/${versionPath}` },
+        );
+      }
     }
-  }
 
-  archive.stream.append(
-    readme({
+    archive.stream.append(
+      readme({
+        servicesCount: services.size,
+        releaseDate,
+        firstVersionDate,
+        lastVersionDate,
+      }),
+      { name: `${archive.basename}/README.md` },
+    );
+    archive.stream.append(
+      fsApi.readFileSync(path.resolve(__dirname, '../assets/LICENSE')),
+      { name: `${archive.basename}/LICENSE` },
+    );
+
+    await Promise.all([ archive.stream.finalize(), archive.done ]); // Both promises settle on the same underlying zip module error; awaiting only `done` left `finalize`'s rejection unhandled
+    await fs.rename(temporaryArchivePath, archivePath); // The archive appears under its final name only once complete, so a crash never leaves a truncated dataset where the collection API would serve it
+
+    const { size } = await fs.stat(archivePath);
+
+    return {
       servicesCount: services.size,
-      releaseDate,
+      termsCount: terms.size,
+      versionsCount,
       firstVersionDate,
       lastVersionDate,
-    }),
-    { name: `${archive.basename}/README.md` },
-  );
-  archive.stream.append(
-    fsApi.readFileSync(path.resolve(__dirname, '../assets/LICENSE')),
-    { name: `${archive.basename}/LICENSE` },
-  );
-
-  archive.stream.finalize();
-
-  await archive.done;
-  await versionsRepository.finalize();
-
-  return {
-    servicesCount: services.size,
-    firstVersionDate,
-    lastVersionDate,
-  };
+      size,
+      sha256: archive.hash.digest('hex'),
+    };
+  } catch (error) {
+    archive.stream.destroy();
+    await archive.done.catch(() => {}); // The write stream has to be closed before the file can be removed on Windows
+    await fs.rm(temporaryArchivePath, { force: true });
+    throw error;
+  } finally {
+    await versionsRepository.finalize();
+  }
 }
 
-async function initializeArchive(targetPath) {
+async function initializeArchive(targetPath, basename) {
   await fs.mkdir(path.dirname(targetPath), { recursive: true });
 
-  const basename = path.basename(targetPath, path.extname(targetPath));
-
   const output = fsApi.createWriteStream(targetPath);
   const stream = archiver(ARCHIVE_FORMAT, { zlib: { level: 9 } }); // set compression to max level
+  const hash = createHash('sha256');
 
-  const done = new Promise(resolve => {
-    output.on('close', resolve);
-  });
+  stream.on('data', chunk => hash.update(chunk)); // Hashing the bytes on their way to disk avoids reading back an archive that can weigh gigabytes
 
-  stream.pipe(output);
+  const done = pipeline(stream, output); // Unlike waiting for the close event, the pipeline promise also rejects when either stream fails
 
-  return { basename, stream, done };
+  return { basename, stream, hash, done };
 }
 
 function generateVersionPath({ serviceId, termsType, fetchDate }) {

package/scripts/dataset/export/index.test.js

@@ -1,20 +1,26 @@
+import { createHash } from 'crypto';
 import fs from 'fs/promises';
 import path from 'path';
 import { fileURLToPath } from 'url';
 
 import { expect, use } from 'chai';
+import chaiAsPromised from 'chai-as-promised';
 import config from 'config';
 import dircompare from 'dir-compare';
 import mime from 'mime';
 import StreamZip from 'node-stream-zip';
+import sinon from 'sinon';
 
 import GitRepository from '../../../src/archivist/recorder/repositories/git/index.js';
 import Version from '../../../src/archivist/recorder/version.js';
+import { TEMPORARY_SUFFIX } from '../../../src/dataset/storage.js';
 
 import generateArchive from './index.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
+use(chaiAsPromised);
+
 const FIRST_SERVICE_PROVIDER_ID = 'ServiceA';
 const SECOND_SERVICE_PROVIDER_ID = 'ServiceB';
 
@@ -41,6 +47,7 @@ describe('Export', () => {
     const EXPECTED_DATASET_PATH = path.resolve(__dirname, './test/fixtures/dataset');
 
     let repository;
+    let stats;
     let zip;
 
     before(async function () {
@@ -84,7 +91,7 @@ describe('Export', () => {
         snapshotId: SNAPSHOT_ID,
       }));
 
-      await generateArchive({
+      stats = await generateArchive({
         archivePath: ARCHIVE_PATH,
         releaseDate: new Date(RELEASE_DATE),
       });
@@ -108,6 +115,71 @@ describe('Export', () => {
     it('has the proper contents', () => {
       expect(`${TMP_PATH}/${ARCHIVE_NAME}`).to.have.sameContentAs(EXPECTED_DATASET_PATH);
     });
+
+    describe('returned stats', () => {
+      it('counts the services', () => {
+        expect(stats.servicesCount).to.equal(2);
+      });
+
+      it('counts the distinct terms', () => {
+        expect(stats.termsCount).to.equal(3);
+      });
+
+      it('counts the versions', () => {
+        expect(stats.versionsCount).to.equal(4);
+      });
+
+      it('exposes the first version date', () => {
+        expect(stats.firstVersionDate).to.deep.equal(new Date(FIRST_FETCH_DATE));
+      });
+
+      it('exposes the last version date', () => {
+        expect(stats.lastVersionDate).to.deep.equal(new Date(THIRD_FETCH_DATE));
+      });
+
+      it('exposes the archive size in bytes', async () => {
+        expect(stats.size).to.equal((await fs.stat(ARCHIVE_PATH)).size);
+      });
+
+      it('exposes the archive SHA-256 checksum', async () => {
+        expect(stats.sha256).to.equal(createHash('sha256').update(await fs.readFile(ARCHIVE_PATH)).digest('hex'));
+      });
+    });
+  });
+
+  context('when the generation fails', () => {
+    const TMP_PATH = path.resolve(__dirname, './tmp');
+    const FAILING_ARCHIVE_PATH = path.resolve(TMP_PATH, 'failing-dataset.zip');
+
+    let error;
+
+    before(async function () {
+      this.timeout(10000);
+      sinon.stub(GitRepository.prototype, 'iterate').throws(new Error('Repository failure'));
+
+      try {
+        await generateArchive({ archivePath: FAILING_ARCHIVE_PATH, releaseDate: new Date(RELEASE_DATE) });
+      } catch (generationError) {
+        error = generationError;
+      }
+    });
+
+    after(async () => {
+      sinon.restore();
+      await fs.rm(TMP_PATH, { recursive: true, force: true });
+    });
+
+    it('rejects with the underlying error', () => {
+      expect(error).to.be.an('error').with.property('message', 'Repository failure');
+    });
+
+    it('leaves no archive at the target path', async () => {
+      await expect(fs.access(FAILING_ARCHIVE_PATH)).to.be.rejected;
+    });
+
+    it('leaves no temporary file', async () => {
+      await expect(fs.access(`${FAILING_ARCHIVE_PATH}${TEMPORARY_SUFFIX}`)).to.be.rejected;
+    });
   });
 });
 

package/scripts/dataset/export/test/fixtures/dataset/README.md

@@ -37,4 +37,4 @@ This dataset represents each version of a document as a separate [Markdown](http
 
 ### License
 
-This dataset is made available under an [Open Database (OdBL) License](https://opendatacommons.org/licenses/odbl/1.0/) by Open Terms Archive Contributors.
+This dataset is made available under an [Open Database (ODbL) License](https://opendatacommons.org/licenses/odbl/1.0/) by Open Terms Archive Contributors.

package/scripts/dataset/index.js

@@ -1,21 +1,43 @@
-import fs from 'fs';
 import path from 'path';
 
 import config from 'config';
 
+import { toISODateWithoutMilliseconds } from '../../src/archivist/utils/date.js';
+import * as license from '../../src/dataset/license.js';
+import DatasetStorage from '../../src/dataset/storage.js';
+
 import generateRelease from './export/index.js';
 import logger from './logger/index.js';
 import publishRelease from './publish/index.js';
 
-export async function release({ shouldPublish, shouldRemoveLocalCopy, fileName }) {
+export async function release({ shouldPublish, fileName }) {
   const releaseDate = new Date();
-  const archiveName = fileName || `${config.get('@opentermsarchive/engine.dataset.title').toLowerCase().replace(/[^a-zA-Z0-9.\-_]/g, '-')}-${releaseDate.toISOString().replace(/T.*/, '')}`;
-  const archivePath = `${path.basename(archiveName, '.zip')}.zip`; // allow to pass filename or filename.zip as the archive name and have filename.zip as the result name
+  const title = config.get('@opentermsarchive/engine.dataset.title');
+  const storage = new DatasetStorage(config.get('@opentermsarchive/engine.dataset.storagePath'));
+  const archiveName = fileName || `${title.toLowerCase().replace(/[^a-zA-Z0-9.\-_]/g, '-')}-${releaseDate.toISOString().replace(/T.*/, '')}`;
+  const filename = `${path.basename(archiveName, '.zip')}.zip`; // allow to pass filename or filename.zip as the archive name and have filename.zip as the result name
+  const archivePath = storage.archivePath(filename);
 
   logger.info('Start exporting dataset…');
 
   const stats = await generateRelease({ archivePath, releaseDate });
 
+  await storage.save({
+    filename,
+    title,
+    license: license.SPDX_ID,
+    releaseDate: toISODateWithoutMilliseconds(releaseDate),
+    firstVersionDate: toISODateWithoutMilliseconds(stats.firstVersionDate),
+    lastVersionDate: toISODateWithoutMilliseconds(stats.lastVersionDate),
+    servicesCount: stats.servicesCount,
+    termsCount: stats.termsCount,
+    versionsCount: stats.versionsCount,
+    size: stats.size,
+    sha256: stats.sha256,
+  });
+
+  await storage.removePreviousArchives().catch(error => logger.warn(`Failed to remove previous dataset archives: ${error.message}`)); // The new dataset is already saved and servable; do not fail the release over stale files left behind
+
   logger.info(`Dataset exported in ${archivePath}`);
 
   if (!shouldPublish) {
@@ -36,12 +58,4 @@ export async function release({ shouldPublish, shouldRemoveLocalCopy, fileName }
       logger.info(`  - ${result.platform}: ${result.url}`);
     });
   }
-
-  if (!shouldRemoveLocalCopy) {
-    return;
-  }
-
-  fs.unlinkSync(archivePath);
-
-  logger.info(`Removed local copy ${archivePath}`);
 }

package/scripts/dataset/index.test.js

@@ -0,0 +1,195 @@
+import { createHash } from 'crypto';
+import fs from 'fs/promises';
+import path from 'path';
+
+import { expect, use } from 'chai';
+import chaiAsPromised from 'chai-as-promised';
+import config from 'config';
+import sinon from 'sinon';
+
+import RepositoryFactory from '../../src/archivist/recorder/repositories/factory.js';
+import Version from '../../src/archivist/recorder/version.js';
+import DatasetStorage, { TEMPORARY_SUFFIX } from '../../src/dataset/storage.js';
+
+import { release } from './index.js';
+
+use(chaiAsPromised);
+
+const FIRST_SERVICE_PROVIDER_ID = 'ServiceA';
+const SECOND_SERVICE_PROVIDER_ID = 'ServiceB';
+
+const FIRST_TERMS_TYPE = 'Terms of Service';
+const SECOND_TERMS_TYPE = 'Privacy Policy';
+
+const FIRST_FETCH_DATE = '2021-01-01T11:27:00.000Z';
+const SECOND_FETCH_DATE = '2021-01-11T11:32:47.000Z';
+const THIRD_FETCH_DATE = '2022-01-06T11:32:47.000Z';
+const FOURTH_FETCH_DATE = '2022-01-01T12:12:24.000Z';
+
+const SNAPSHOT_ID = '721ce4a63ad399ecbdb548a66d6d327e7bc97876';
+
+const STALE_ARCHIVE_FILENAME = 'stale.zip';
+
+describe('Dataset release', () => {
+  describe('#release', () => {
+    const storage = new DatasetStorage(config.get('@opentermsarchive/engine.dataset.storagePath')); // Instantiated up front, so a `before` hook failing partway through still leaves `after` a valid `storage` to clean up
+
+    let repository;
+    let metadata;
+
+    before(async function () {
+      this.timeout(10000);
+      repository = RepositoryFactory.create(config.get('@opentermsarchive/engine.recorder.versions.storage'));
+      await repository.initialize();
+      await repository.removeAll();
+
+      const versions = [
+        [ FIRST_SERVICE_PROVIDER_ID, FIRST_TERMS_TYPE, FIRST_FETCH_DATE ],
+        [ FIRST_SERVICE_PROVIDER_ID, FIRST_TERMS_TYPE, SECOND_FETCH_DATE ],
+        [ SECOND_SERVICE_PROVIDER_ID, FIRST_TERMS_TYPE, THIRD_FETCH_DATE ],
+        [ SECOND_SERVICE_PROVIDER_ID, SECOND_TERMS_TYPE, FOURTH_FETCH_DATE ],
+      ];
+
+      for (const [ serviceId, termsType, fetchDate ] of versions) {
+        await repository.save(new Version({
+          serviceId,
+          termsType,
+          content: `Content of ${serviceId} ${termsType} fetched on ${fetchDate}`,
+          fetchDate,
+          snapshotId: SNAPSHOT_ID,
+        }));
+      }
+
+      await fs.mkdir(storage.path, { recursive: true });
+      await fs.writeFile(storage.archivePath(STALE_ARCHIVE_FILENAME), 'stale archive');
+
+      await release({});
+
+      metadata = await storage.findLatest();
+    });
+
+    after(async () => {
+      await repository.removeAll();
+      await fs.rm(storage.path, { recursive: true, force: true });
+    });
+
+    it('names the archive after the dataset title and the release date', () => {
+      expect(metadata.filename).to.match(/^sandbox-\d{4}-\d{2}-\d{2}\.zip$/);
+    });
+
+    it('stores the archive in the storage directory', async () => {
+      await expect(fs.access(storage.archivePath(metadata.filename))).to.be.fulfilled;
+    });
+
+    it('writes no archive in the current working directory', async () => {
+      await expect(fs.access(path.resolve(process.cwd(), metadata.filename))).to.be.rejected;
+    });
+
+    it('removes previous archives', async () => {
+      await expect(fs.access(storage.archivePath(STALE_ARCHIVE_FILENAME))).to.be.rejected;
+    });
+
+    it('leaves no temporary file', async () => {
+      const entries = await fs.readdir(storage.path);
+
+      expect(entries.filter(entry => entry.endsWith(TEMPORARY_SUFFIX))).to.be.empty;
+    });
+
+    describe('metadata', () => {
+      it('describes the dataset title', () => {
+        expect(metadata.title).to.equal('sandbox');
+      });
+
+      it('describes the license as an SPDX identifier', () => {
+        expect(metadata.license).to.equal('ODbL-1.0');
+      });
+
+      it('describes the release date as an ISO 8601 date without milliseconds', () => {
+        expect(metadata.releaseDate).to.match(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/);
+      });
+
+      it('describes the first version date', () => {
+        expect(metadata.firstVersionDate).to.equal('2021-01-01T11:27:00Z');
+      });
+
+      it('describes the last version date', () => {
+        expect(metadata.lastVersionDate).to.equal('2022-01-06T11:32:47Z');
+      });
+
+      it('counts the services', () => {
+        expect(metadata.servicesCount).to.equal(2);
+      });
+
+      it('counts the distinct terms', () => {
+        expect(metadata.termsCount).to.equal(3);
+      });
+
+      it('counts the versions', () => {
+        expect(metadata.versionsCount).to.equal(4);
+      });
+
+      it('describes the archive size in bytes', async () => {
+        expect(metadata.size).to.equal((await fs.stat(storage.archivePath(metadata.filename))).size);
+      });
+
+      it('describes the archive SHA-256 checksum', async () => {
+        expect(metadata.sha256).to.equal(createHash('sha256').update(await fs.readFile(storage.archivePath(metadata.filename))).digest('hex'));
+      });
+    });
+
+    context('when removing previous archives fails', () => {
+      let error;
+
+      before(async function () {
+        this.timeout(10000);
+
+        const staleArchivePath = storage.archivePath(metadata.filename); // the archive from the outer release(), now standing in the way of this second one
+        const originalRm = fs.rm.bind(fs);
+
+        sinon.stub(fs, 'rm').callsFake((path, options) => (path === staleArchivePath ? Promise.reject(new Error('Permission denied')) : originalRm(path, options)));
+
+        try {
+          await release({ fileName: 'second-release' });
+        } catch (releaseError) {
+          error = releaseError;
+        }
+      });
+
+      after(() => {
+        sinon.restore();
+      });
+
+      it('resolves despite the cleanup failure', () => {
+        expect(error).to.be.undefined;
+      });
+    });
+
+    context('when a custom file name is given without extension', () => {
+      let customMetadata;
+
+      before(async function () {
+        this.timeout(10000);
+        await release({ fileName: 'custom' });
+        customMetadata = await storage.findLatest();
+      });
+
+      it('names the archive after the given file name', () => {
+        expect(customMetadata.filename).to.equal('custom.zip');
+      });
+    });
+
+    context('when a custom file name is given with a .zip extension', () => {
+      let customMetadata;
+
+      before(async function () {
+        this.timeout(10000);
+        await release({ fileName: 'custom.zip' });
+        customMetadata = await storage.findLatest();
+      });
+
+      it('names the archive after the given file name', () => {
+        expect(customMetadata.filename).to.equal('custom.zip');
+      });
+    });
+  });
+});

package/scripts/dataset/logger/index.js

@@ -33,6 +33,7 @@ logger.format = combine(
 
 export function createModuleLogger(moduleName) {
   return {
+    debug: message => logger.debug(message, { module: moduleName }),
     info: message => logger.info(message, { module: moduleName }),
     warn: message => logger.warn(message, { module: moduleName }),
     error: message => logger.error(message, { module: moduleName }),