Sm/sdr-mdapi-zip (#516)

* fix: use the other coverageReport

* feat: add type omniInteractionConfig

* fix: dataMapping is mcf

* chore: skip other unsupported features

* chore: adding types for SDR

* feat: zip and mdapiDir

* refactor: stream2buffer on streams class

* fix: throw when no zip buffer possible

* test: ut for stream2buffer

Co-authored-by: Steve Hetzel <[email protected]>

Author: mshanemc

LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2021, Salesforce.com, Inc.
+Copyright (c) 2022, Salesforce.com, Inc.
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

src/client/metadataApiDeploy.ts

@@ -6,12 +6,15 @@
  */
 import { basename, dirname, extname, join } from 'path';
 import { isString } from '@salesforce/ts-types';
+import { create as createArchive } from 'archiver';
+import * as fs from 'graceful-fs';
 import { MetadataConverter } from '../convert';
 import { ComponentLike, SourceComponent } from '../resolve';
 import { normalizeToArray } from '../utils';
 import { ComponentSet } from '../collections';
 import { registry } from '../registry';
 import { MissingJobIdError } from '../errors';
+import { stream2buffer } from '../convert/streams';
 import { MetadataTransfer, MetadataTransferOptions } from './metadataTransfer';
 import {
   AsyncResult,
@@ -23,7 +26,6 @@ import {
   MetadataTransferResult,
 } from './types';
 import { DiagnosticUtil } from './diagnosticUtil';
-
 export class DeployResult implements MetadataTransferResult {
   public readonly response: MetadataApiDeployStatus;
   public readonly components: ComponentSet;
@@ -208,6 +210,14 @@ export class DeployResult implements MetadataTransferResult {
 
 export interface MetadataApiDeployOptions extends MetadataTransferOptions {
   apiOptions?: ApiOptions;
+  /**
+   * Path to a zip file containing mdapi-formatted code and a package.xml
+   */
+  zipPath?: string;
+  /**
+   * Path to a directory containing mdapi-formatted code and a package.xml
+   */
+  mdapiPath?: string;
 }
 
 export class MetadataApiDeploy extends MetadataTransfer<MetadataApiDeployStatus, DeployResult> {
@@ -302,8 +312,7 @@ export class MetadataApiDeploy extends MetadataTransfer<MetadataApiDeployStatus,
   }
 
   protected async pre(): Promise<AsyncResult> {
-    const converter = new MetadataConverter();
-    const { zipBuffer } = await converter.convert(this.components, 'metadata', { type: 'zip' });
+    const zipBuffer = await this.getZipBuffer();
     const connection = await this.getConnection();
     await this.maybeSaveTempDirectory('metadata');
     return connection.deploy(zipBuffer, this.options.apiOptions);
@@ -313,4 +322,32 @@ export class MetadataApiDeploy extends MetadataTransfer<MetadataApiDeployStatus,
   protected async post(result: MetadataApiDeployStatus): Promise<DeployResult> {
     return new DeployResult(result, this.components);
   }
+
+  private async getZipBuffer(): Promise<Buffer> {
+    if (this.options.mdapiPath) {
+      if (!fs.existsSync(this.options.mdapiPath) || !fs.lstatSync(this.options.mdapiPath).isDirectory()) {
+        throw new Error(`Deploy directory ${this.options.mdapiPath} does not exist or is not a directory`);
+      }
+      // make a zip from the given directory
+      const zip = createArchive('zip', { zlib: { level: 9 } });
+      // anywhere not at the root level is fine
+      zip.directory(this.options.mdapiPath, 'zip');
+      await zip.finalize();
+      return stream2buffer(zip);
+    }
+    // read the zip into a buffer
+    if (this.options.zipPath) {
+      if (!fs.existsSync(this.options.zipPath)) {
+        throw new Error(`Zip file ${this.options.zipPath} does not exist`);
+      }
+      // does encoding matter for zip files? I don't know
+      return fs.promises.readFile(this.options.zipPath);
+    }
+    if (this.options.components) {
+      const converter = new MetadataConverter();
+      const { zipBuffer } = await converter.convert(this.components, 'metadata', { type: 'zip' });
+      return zipBuffer;
+    }
+    throw new Error('Options should include components, zipPath, or mdapiPath');
+  }
 }

src/convert/streams.ts

@@ -5,7 +5,7 @@
  * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
  */
 import { basename, dirname, isAbsolute, join } from 'path';
-import { pipeline as cbPipeline, Readable, Transform, Writable } from 'stream';
+import { pipeline as cbPipeline, Readable, Transform, Writable, Stream } from 'stream';
 import { promisify } from 'util';
 import { Archiver, create as createArchive } from 'archiver';
 import { createWriteStream, existsSync } from 'graceful-fs';
@@ -24,6 +24,17 @@ import { SfdxFileFormat, WriteInfo, WriterFormat } from './types';
 
 export const pipeline = promisify(cbPipeline);
 
+export const stream2buffer = async (stream: Stream): Promise<Buffer> => {
+  return new Promise<Buffer>((resolve, reject) => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const buf = Array<any>();
+
+    stream.on('data', (chunk) => buf.push(chunk));
+    stream.on('end', () => resolve(Buffer.concat(buf)));
+    // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+    stream.on('error', (err) => reject(`error converting stream - ${err}`));
+  });
+};
 export class ComponentReader extends Readable {
   private iter: Iterator<SourceComponent>;
 

test/client/metadataApiDeploy.test.ts

@@ -35,6 +35,9 @@ describe('MetadataApiDeploy', () => {
 
   describe('Lifecycle', () => {
     describe('start', () => {
+      it('should not convert zip, but read from fs', async () => {});
+      it('should not mdapiDir, but generate zip buffer from it', async () => {});
+
       it('should convert to metadata format and create zip', async () => {
         const components = new ComponentSet([matchingContentFile.COMPONENT]);
         const { operation, convertStub } = await stubMetadataDeploy(env, {
@@ -756,6 +759,26 @@ describe('MetadataApiDeploy', () => {
   });
 
   describe('Constructor', () => {
+    it('should allow zip file', () => {
+      const mdApiDeploy = new MetadataApiDeploy({
+        usernameOrConnection: 'testing',
+        zipPath: 'foo/myZip.zip',
+      });
+      // @ts-ignore testing private property
+      const mdOpts = mdApiDeploy.options;
+      expect(mdOpts.zipPath).to.equal('foo/myZip.zip');
+    });
+
+    it('should allow mdapi path', () => {
+      const mdApiDeploy = new MetadataApiDeploy({
+        usernameOrConnection: 'testing',
+        mdapiPath: 'foo/myDir',
+      });
+      // @ts-ignore testing private property
+      const mdOpts = mdApiDeploy.options;
+      expect(mdOpts.mdapiPath).to.equal('foo/myDir');
+    });
+
     it('should merge default API options', () => {
       const mdApiDeploy = new MetadataApiDeploy({
         usernameOrConnection: 'testing',

test/convert/streams.test.ts

@@ -518,4 +518,17 @@ describe('Streams', () => {
       expect(jsToXml.read().toString()).to.be.equal(expectedBody);
     });
   });
+
+  describe('stream2buffer', () => {
+    it('returns the stream content in a buffer', async () => {
+      const stream = new Readable();
+      stream._read = (): void => {
+        stream.push('foo');
+        stream.push(null);
+      };
+      const buffer = await streams.stream2buffer(stream);
+      expect(buffer).to.be.instanceof(Buffer);
+      expect(buffer.toString()).to.equal('foo');
+    });
+  });
 });

test/mock/client/transferOperations.ts

@@ -40,6 +40,8 @@ export const MOCK_RECENTLY_VALIDATED_ID_SOAP = '0987654321';
 
 interface DeployStubOptions {
   components?: ComponentSet;
+  zipPath?: string;
+  mdapiPath?: string;
   componentSuccesses?: Partial<DeployMessage> | Array<Partial<DeployMessage>>;
   componentFailures?: Partial<DeployMessage> | Array<Partial<DeployMessage>>;
   apiOptions?: MetadataApiDeployOptions;