@api-client/core 0.5.19 → 0.5.20

package/src/models/ClientCertificate.ts

@@ -1,54 +1,124 @@
+import { base64ToBuffer, bufferToBase64 } from '../lib/Buffer.js';
+import v4 from '../lib/uuid.js';
+
 export type CertificateType = 'p12' | 'pem';
 
+export const Kind = 'Core#Certificate';
+
+export type CertificateDataFormat = string | ArrayBuffer | Buffer | Uint8Array;
+
 /**
  * Represents a single certificate object (cert/key)
  */
-export interface ICertificate {
+export interface ICertificateData {
   /**
    * The certificate to use.
    * The `p12` type certificate must be a Buffer.
    */
-  data: string|ArrayBuffer|Buffer|Uint8Array;
+  data: CertificateDataFormat;
   /**
    * A passphrase to use to unlock the certificate.
    */
   passphrase?: string;
   /**
-   * The original data type of the certificate. This is used by the data store
+   * The original data type of the certificate. This is only used internally by the data store
    * to move between buffers and string values stored in the store.
-   * By any means, outside the internal procedure of the data store this
-   * filed is always `undefined` and the `data` contains the original data format.
+   * Outside the internal procedure of the data store this
+   * is always `undefined` and the `data` contains the original data format.
    */
-  type?: string;
+  type?: 'buffer';
 }
 
-/**
- * Represents a complete certificate configuration required to make
- * a HTTP request.
- */
-export interface IRequestCertificate {
- /**
+export interface ICertificate {
+  kind: typeof Kind;
+  /**
+   * The data store key to refer.
+   */
+  key: string;
+  /**
+   * Custom name of the certificate.
+   */
+  name: string;
+  /**
+   * Timestamp when the certificate was inserted into the data store.
+   * Required when returning a result. Auto-generated when inserting, if missing.
+   */
+  created?: number;
+  /**
    * Certificate type. Either `p12` or `pem`.
    */
   type: CertificateType;
   /**
    * Certificate or list of certificates to use.
    */
-  cert: ICertificate|ICertificate[];
+  cert: ICertificateData;
+}
+
+export interface IP12Certificate extends ICertificate {
+  type: 'p12';
+}
+
+/**
+ * Represents a complete certificate configuration required to make
+ * an HTTP request.
+ */
+export interface IPemCertificate extends ICertificate {
+  type: 'pem';
   /**
-   * Key for the `pem` type certificate.
+   * The key for the `pem` type certificate.
    */
-  key?: ICertificate|ICertificate[];
+  certKey: ICertificateData;
+}
+
+export type HttpCertificate = IP12Certificate | IPemCertificate;
+
+export interface IPemCreateOptions {
+  type: 'p12';
+  /**
+   * The certificate contents.
+   */
+  cert: CertificateDataFormat; 
+  /**
+   * The key contents.
+   */
+  key: CertificateDataFormat; 
+  /**
+   * Optional name for the certificate.
+   */
+  name?: string; 
+  /**
+   * Optional passphrase for the key.
+   */
+  passphrase?: string;
 }
 
+export interface IP12CreateOptions {
+  type: 'pem';
+  /**
+   * The certificate contents.
+   */
+  cert: CertificateDataFormat;
+  /**
+   * Optional name for the certificate.
+   */
+  name?: string; 
+  /**
+   * Optional passphrase for the certificate.
+   */
+  passphrase?: string;
+}
+
+export type ICertificateCreateOptions = IPemCreateOptions | IP12CreateOptions;
+
 /**
- * Client certificate index definition for listings. 
+ * A class that represents a certificate in the system
  */
-export interface ICertificateIndex {
+export class Certificate {
+  kind = Kind;
   /**
-   * Certificate type. Either `p12` or `pem`.
+   * The data store key to refer.
    */
-  type: CertificateType;
+  key: string;
   /**
    * Custom name of the certificate.
    */
@@ -58,11 +128,140 @@ export interface ICertificateIndex {
    * Required when returning a result. Auto-generated when inserting, if missing.
    */
   created?: number;
-}
+  /**
+   * Certificate type. Either `p12` or `pem`.
+   */
+  type: CertificateType;
+  /**
+   * Certificate or list of certificates to use.
+   */
+  cert: ICertificateData;
+  /**
+   * The key for the `pem` type certificate.
+   */
+  certKey?: ICertificateData;
+  
+  /**
+   * Creates a new certificate instance for a PEM key
+   * 
+   * @param pem The certificate contents
+   * @param key The key contents
+   * @param name The certificate name
+   * @param keyPassphrase The key passphrase
+   */
+  static fromPem(pem: CertificateDataFormat, key: CertificateDataFormat, name = 'New PEM certificate', keyPassphrase?: string): Certificate {
+    const init: IPemCertificate = {
+      kind: Kind,
+      cert: {
+        data: pem,
+      },
+      certKey: {
+        data: key,
+      },
+      key: v4(),
+      name,
+      type: 'pem',
+    };
+    if (keyPassphrase) {
+      init.certKey.passphrase = keyPassphrase;
+    }
+    return new Certificate(init);
+  }
 
-/**
- * A base client certificate object used in API Client to create / list objects.
- * This is not a data entity but rather something used to outside of a context of a data store.
- */
-export interface IClientCertificate extends IRequestCertificate, ICertificateIndex {
+  /**
+   * Creates a new certificate instance for a P12 key
+   * 
+   * @param cert The certificate contents
+   * @param name The certificate name
+   * @param passphrase The key passphrase
+   */
+  static fromP12(cert: CertificateDataFormat, name = 'New P12 certificate', passphrase?: string): Certificate {
+    const init: IP12Certificate = {
+      kind: Kind,
+      cert: {
+        data: cert,
+      },
+      key: v4(),
+      name,
+      type: 'p12',
+    };
+    if (passphrase) {
+      init.cert.passphrase = passphrase;
+    }
+    return new Certificate(init);
+  }
+
+  constructor(certificate: HttpCertificate) {
+    const { type, cert, key=v4(), name='', created } = certificate;
+    this.key = key;
+    this.name = name;
+    this.type = type;
+    this.cert = this.fromStore(cert);
+    if (typeof created === 'number') {
+      this.created = created;
+    }
+    if (type === 'pem') {
+      this.certKey = this.fromStore(certificate.certKey);
+    }
+  }
+
+  /**
+   * When needed it reads the certificate's original format.
+   * @param data The certificate data.
+   * @returns The restored certificate.
+   */
+  fromStore(data: ICertificateData): ICertificateData {
+    if (data.type) {
+      delete data.type;
+      const content = data.data as string;
+      data.data = base64ToBuffer(content);
+    }
+    return data;
+  }
+
+  /**
+   * Prepares certificate object to be stored in the data store.
+   * If the `data` property is not string then it assumes buffer (either
+   * Node's or ArrayBuffer). In this case it converts buffer to base64 string.
+   * It also adds `type` property set to `buffer` for the `fromStore()`
+   * function to recognize what to do with the data.
+   *
+   * Note, for optimization, PEM keys should be strings as the content of the
+   * certificate is already a base62 string. To spare double base64 conversion
+   * use string data.
+   *
+   * @param data The certificate data object.
+   * @throws When data is not set
+   */
+  toStore(data: ICertificateData): ICertificateData {
+    if (!data) {
+      throw new Error('Certificate data is missing.');
+    }
+    if (!data.data) {
+      throw new Error('Certificate content not set.');
+    }
+    if (typeof data.data !== 'string') {
+      data.type = 'buffer';
+      const buff = data.data as Buffer;
+      data.data = bufferToBase64(buff);
+    }
+    return data;
+  }
+
+  toJSON(): HttpCertificate {
+    const result: IP12Certificate = {
+      kind: Kind,
+      key: this.key,
+      cert: this.toStore(this.cert),
+      name: this.name,
+      type: 'p12',
+    };
+
+    if (this.type === 'pem') {
+      const typed = (result as unknown) as IPemCertificate;
+      typed.certKey = this.toStore(this.certKey!);
+    }
+
+    return result;
+  }
 }

package/src/models/Request.ts

@@ -1,7 +1,7 @@
 import { IRequestConfig, RequestConfig } from './RequestConfig.js';
 import { Thing, IThing, Kind as ThingKind } from './Thing.js';
 import { IRequestActions, RequestActions } from './RequestActions.js';
-import { IRequestCertificate } from './ClientCertificate.js';
+import { HttpCertificate, Certificate } from './ClientCertificate.js';
 import { IRequestAuthorization, RequestAuthorization } from './RequestAuthorization.js';
 import { IRequestLog, RequestLog, Kind as LogKind } from './RequestLog.js';
 import { SentRequest } from './SentRequest.js';
@@ -64,7 +64,7 @@ export interface IRequest {
   /**
    * The list of certificates to use with the request.
    */
-  clientCertificate?: IRequestCertificate;
+  clientCertificate?: HttpCertificate;
 }
 
 export class Request {
@@ -99,7 +99,7 @@ export class Request {
   /**
    * The list of certificates to use with the request.
    */
-  clientCertificate?: IRequestCertificate;
+  clientCertificate?: Certificate;
 
   /**
    * Creates a request from an URL.
@@ -373,7 +373,7 @@ export class Request {
       this.actions = undefined;
     }
     if (clientCertificate) {
-      this.clientCertificate = clientCertificate;
+      this.clientCertificate = new Certificate(clientCertificate);
     } else {
       this.clientCertificate = undefined;
     }
@@ -401,7 +401,7 @@ export class Request {
       result.actions = this.actions.toJSON();
     }
     if (this.clientCertificate) {
-      result.clientCertificate = { ...this.clientCertificate };
+      result.clientCertificate = this.clientCertificate.toJSON();
     }
     return result;
   }

package/src/runtime/http-engine/CoreEngine.ts

@@ -728,12 +728,15 @@ export class CoreEngine extends HttpEngine {
       return;
     }
     if (data.length === 0) {
+      if (this.currentResponse?.status === 204) {
+        this._reportResponse();
+        return;
+      }
       if (this.currentHeaders.has('Content-Length')) {
         // If the server do not close the connection and clearly indicate that
         // there are no further data to receive the app can close the connection
         // and prepare the response.
         const length = Number(this.currentHeaders.get('Content-Length'));
-        // NaN never equals NaN. This is faster.
         if (!Number.isNaN(length) && length === 0) {
           this._reportResponse();
           return;

package/src/runtime/http-engine/HttpEngine.ts

@@ -10,7 +10,7 @@ import { IHttpRequest, HttpRequest } from '../../models/HttpRequest.js';
 import { IRequestBaseConfig } from '../../models/RequestConfig.js';
 import { IRequestAuthorization } from '../../models/RequestAuthorization.js';
 import { HostRule } from '../../models/HostRule.js';
-import { IRequestCertificate } from '../../models/ClientCertificate.js';
+import { HttpCertificate } from '../../models/ClientCertificate.js';
 import { SentRequest } from '../../models/SentRequest.js';
 import { Response } from '../../models/Response.js';
 import { ErrorResponse } from '../../models/ErrorResponse.js';
@@ -40,7 +40,7 @@ export interface HttpEngineOptions extends IRequestBaseConfig {
   /**
    * A certificate to use with the request.
    */
-  certificates?: IRequestCertificate[];
+  certificates?: HttpCertificate[];
 }
 
 export interface RequestStats {
@@ -385,7 +385,7 @@ export abstract class HttpEngine extends EventEmitter {
 
   /**
    * Reports response when redirected.
-   * @param  Received status code
+   * @param status Received status code
    * @return True if the request has been redirected.
    */
   _reportRedirect(status: number): boolean {
@@ -734,51 +734,57 @@ Check your request parameters.`);
    * @param certificate List of certificate configurations.
    * @param options Request options. Cert agent options are added to this object.
    */
-  _addClientCertificate(certificate: IRequestCertificate, options: tls.ConnectionOptions): void {
+  _addClientCertificate(certificate: HttpCertificate, options: tls.ConnectionOptions): void {
     if (!certificate) {
       return;
     }
     const cert = { ...certificate };
-    if (!Array.isArray(cert.cert)) {
-      cert.cert = [cert.cert];
-    }
     if (cert.type === 'p12') {
       if (!options.pfx) {
         options.pfx = [];
       }
-      const added = cert.cert.map((item) => {
-        const struct: tls.PxfObject = {
-          buf: Buffer.from(item.data as string),
-        };
-        if (item.passphrase) {
-          struct.passphrase = item.passphrase;
+      const struct: tls.PxfObject = {
+        buf: Buffer.from(cert.cert.data as string),
+      };
+      if (cert.cert.passphrase) {
+        struct.passphrase = cert.cert.passphrase;
+      }
+      if (!Array.isArray(options.pfx)) {
+        if (options.pfx) {
+          options.pfx = [options.pfx];
+        } else {
+          options.pfx = [];
         }
-        return struct;
-      });
-      options.pfx = (options.pfx as tls.PxfObject[]).concat(added);
+      }
+      options.pfx.push(struct);
     } else if (cert.type === 'pem') {
       if (!options.cert) {
         options.cert = [];
       }
-      const added = cert.cert.map((item) => Buffer.from(item.data as string));
-      options.cert = (options.cert as Buffer[]).concat(added);
-      if (cert.key) {
-        if (!Array.isArray(cert.key)) {
-          cert.key = [cert.key];
-        }
-        if (!options.key) {
-          options.key = [];
+      if (!Array.isArray(options.cert)) {
+        if (options.cert) {
+          options.cert = [options.cert];
+        } else {
+          options.cert = [];
         }
-        const keys = cert.key.map((item) => {
-          const struct: tls.KeyObject = {
-            pem: Buffer.from(item.data as string),
-          };
-          if (item.passphrase) {
-            struct.passphrase = item.passphrase;
+      }
+      const added = Buffer.from(cert.cert.data as string);
+      options.cert.push(added);
+      if (cert.certKey) {
+        if (!Array.isArray(options.key)) {
+          if (options.key) {
+            options.key = [options.key];
+          } else {
+            options.key = [];
           }
-          return struct;
-        });
-        options.key = (options.key as tls.KeyObject[]).concat(keys);
+        }
+        const struct: tls.KeyObject = {
+          pem: Buffer.from(cert.certKey.data as string),
+        };
+        if (cert.certKey.passphrase) {
+          struct.passphrase = cert.certKey.passphrase;
+        }
+        options.key.push(struct);
       }
     }
   }

package/src/runtime/modules/ModulesRegistry.ts

@@ -8,7 +8,7 @@ import { ClientCertificateEvents } from '../../events/models/ClientCertificateEv
 import { IRequestAuthorization } from '../../models/RequestAuthorization.js';
 import { IRequestConfig } from '../../models/RequestConfig.js';
 import { IRequestLog } from '../../models/RequestLog.js';
-import { IRequestCertificate } from '../../models/ClientCertificate.js';
+import { HttpCertificate } from '../../models/ClientCertificate.js';
 
 export interface RegisteredRequestModule {
   fn: (request: IHttpRequest, context: ExecutionContext) => Promise<number>;
@@ -49,7 +49,7 @@ export interface ExecutionContext {
   /**
    * Can be altered by the actions.
    */
-  certificates?: IRequestCertificate[];
+  certificates?: HttpCertificate[];
 }
 
 export interface ExecutionEvents {

package/src/runtime/node/ProjectRequestRunner.ts

@@ -136,7 +136,7 @@ export class ProjectRequestRunner extends EventEmitter {
       factory.actions = request.actions.toJSON();
     }
     if (request.clientCertificate) {
-      factory.certificates = [request.clientCertificate];
+      factory.certificates = [request.clientCertificate.toJSON()];
     }
     if (config.enabled !== false) {
       factory.config = config.toJSON();

package/src/runtime/node/RequestFactory.ts

@@ -3,7 +3,7 @@ import { IHttpRequest } from '../../models/HttpRequest.js';
 import { IRequestConfig, IRequestBaseConfig } from '../../models/RequestConfig.js';
 import { IRequestAuthorization } from '../../models/RequestAuthorization.js';
 import { IRequestActions } from '../../models/RequestActions.js';
-import { IRequestCertificate } from '../../models/ClientCertificate.js';
+import { HttpCertificate } from '../../models/ClientCertificate.js';
 import { IRequestLog } from '../../models/RequestLog.js';
 import { VariablesProcessor } from '../variables/VariablesProcessor.js';
 import { IRunnableAction } from '../../models/actions/RunnableAction.js';
@@ -57,7 +57,7 @@ export class RequestFactory {
   /**
    * The list of certificates to use with the request.
    */
-  certificates?: IRequestCertificate[];
+  certificates?: HttpCertificate[];
   /**
    * The cumulative list of all variables to be applied to the request and other properties.
    * The variables must be already processed for variables in values (evaluated).