@sudoplatform/sudo-common 7.1.2 → 7.1.3

package/src/types/types.ts

@@ -1,129 +0,0 @@
-/**
- * Generic type for paginated results from list queries
- */
-export interface ListOutput<T> {
-  items: T[]
-  nextToken?: string
-}
-
-/**
- * Cache policy that determines how data is accessed when performing a query method
- * from the Email Service.
- */
-export enum CachePolicy {
-  // Use the device cached data.
-  CacheOnly = 'cache-only',
-  // Query and use the data on the server.
-  RemoteOnly = 'network-only',
-}
-
-export interface Owner {
-  id: string
-  issuer: string
-}
-
-/**
- * A filter to use on string fields when listing items in a repository
- */
-export interface StringFilter {
-  ne?: string
-  eq?: string
-  beginsWith?: string
-}
-
-/**
- * A filter to use on string fields when listing items in a repository
- */
-export interface BooleanFilter {
-  eq?: boolean
-  ne?: boolean
-}
-
-/**
- * Encryption algorithm names that are
- * supported by the Sudo Platform and can be used
- * between devices.
- */
-export enum EncryptionAlgorithm {
-  AesCbcPkcs7Padding = 'AES/CBC/PKCS7Padding',
-  AesGcmNoPadding = 'AES/GCM/NoPadding',
-  RsaOaepSha1 = 'RSA/OAEPWithSHA-1',
-}
-
-export type Subset<T, S> = Pick<S, Extract<keyof T, keyof S>> &
-  Partial<Record<Exclude<keyof T, keyof S>, never>>
-
-/**
- * Status of the list operation result.
- */
-export enum ListOperationResultStatus {
-  /**
-   * The operation completed successfully.
-   */
-  Success = 'Success',
-  /**
-   * The operation completed but some items had errors during
-   * processing.
-   */
-  Partial = 'Partial',
-  /**
-   * The operation failed and no list item could be returned.
-   */
-  Failure = 'Failure',
-}
-
-export interface ListOperationSuccessResult<T> {
-  /**
-   * Operation status.
-   */
-  status: ListOperationResultStatus.Success
-  /**
-   * List of items that were successfully processed.
-   */
-  items: T[]
-  /**
-   * Pagination token.
-   */
-  nextToken?: string
-}
-
-export interface ListOperationFailureResult {
-  /**
-   * Operation status.
-   */
-  status: ListOperationResultStatus.Failure
-  /**
-   * The error that caused the failure.
-   */
-  cause: Error
-}
-
-export interface ListOperationPartialResult<T, S extends Subset<S, T>> {
-  /**
-   * Operation status.
-   */
-  status: ListOperationResultStatus.Partial
-  /**
-   * List of items that were successfully processed.
-   */
-  items: T[]
-  /**
-   * List of items that failed to be processed and the error
-   * that caused the failure.
-   */
-  failed: { item: Omit<T, keyof S>; cause: Error }[]
-  /**
-   * Pagination token.
-   */
-  nextToken?: string
-}
-
-/**
- * Result of a list operation. T is the expected item type and
- * S is a subset of T's properties that won't be present if the
- * additional processing after the item has been fetched fails.
- */
-export type ListOperationResult<T, S extends Subset<S, T> = T> =
-  | ListOperationSuccessResult<T>
-  | ListOperationFailureResult
-  | ListOperationPartialResult<T, S>

package/src/utils/base64.ts

@@ -1,75 +0,0 @@
-import { Buffer as BufferUtil } from './buffer'
-/**
- * Utility class for Base64 encoding and decoding.
- */
-export class Base64 {
-  private static URLSafeEncodeTransform(input: string): string {
-    return input
-      .replace(/\+/g, '-') // Convert '+' to '-'
-      .replace(/\//g, '_') // Convert '/' to '_'
-      .replace(/=+$/, '') // Remove ending '='
-  }
-  private static URLSafeDecodeTransform(input: string): string {
-    return input
-      .replace(/\-/g, '+') // Convert '-' to '+'
-      .replace(/\_/g, '/') // Convert '_' to '/'
-  }
-
-  static decode(encoded: string): ArrayBuffer {
-    return BufferUtil.fromString(atob(encoded))
-  }
-
-  static encode(buffer: ArrayBuffer): string {
-    return btoa(BufferUtil.toString(buffer))
-  }
-
-  static decodeString(encoded: string): string {
-    return atob(encoded)
-  }
-
-  static encodeString(string: string): string {
-    return btoa(string)
-  }
-
-  /**
-   * Encode a URL safe ArrayBuffer
-   * @param {ArrayBuffer} input buffer to be encoded
-   * @returns {string} encoded string
-   */
-  static urlSafeEncode({ input }: { input: ArrayBuffer }): string {
-    return this.URLSafeEncodeTransform(this.encode(input))
-  }
-
-  /**
-   * Decode into a URL safe ArrayBuffer
-   * @param {string} input string to be decoded
-   * @returns {ArrayBuffer} decoded ArrayBuffer
-   */
-  static urlSafeDecode({ encoded }: { encoded: string }): ArrayBuffer {
-    encoded = this.URLSafeDecodeTransform(encoded)
-    return this.decode(encoded)
-  }
-
-  /**
-   * Encode a URL safe string
-   * @param {string} input string to be encoded
-   * @returns {string} encoded string
-   */
-  static urlSafeEncodeString({ input }: { input: string }): string {
-    return this.URLSafeEncodeTransform(this.encodeString(input))
-  }
-
-  /**
-   * Decode a URL safe string
-   * @param {string} input string to be decoded
-   * @returns {string} decoded string
-   */
-  static urlSafeDecodeString({ encoded }: { encoded: string }): string {
-    encoded = this.URLSafeDecodeTransform(encoded)
-    return Buffer.from(this.decode(encoded)).toString('utf8')
-  }
-
-  static UrlSafeValidate(encoded: string): boolean {
-    return /^[A-Za-z0-9\-_]+$/.test(encoded)
-  }
-}

package/src/utils/buffer.ts

@@ -1,39 +0,0 @@
-/**
- * Utility class for operating on ArrayBuffer.
- */
-export class Buffer {
-  static concat(lhs: ArrayBuffer, rhs: ArrayBuffer): ArrayBuffer {
-    const combined = new Uint8Array(lhs.byteLength + rhs.byteLength)
-    combined.set(new Uint8Array(lhs), 0)
-    combined.set(new Uint8Array(rhs), lhs.byteLength)
-    return combined.buffer
-  }
-
-  static split(
-    buffer: ArrayBuffer,
-    lhsLength: number,
-  ): { lhs: ArrayBuffer; rhs: ArrayBuffer } {
-    const array = new Uint8Array(buffer)
-    const lhs = array.slice(0, lhsLength)
-    const rhs = array.slice(lhsLength, array.length)
-    return { lhs, rhs }
-  }
-
-  static toString(buffer: ArrayBuffer): string {
-    let s = ''
-    const bytes = new Uint8Array(buffer)
-    const len = bytes.byteLength
-    for (let i = 0; i < len; i++) {
-      s += String.fromCharCode(bytes[i])
-    }
-    return s
-  }
-
-  static fromString(s: string): Uint8Array {
-    return Uint8Array.from(s, (c) => c.charCodeAt(0))
-  }
-
-  static isArrayBuffer(u: unknown): u is ArrayBuffer {
-    return ArrayBuffer.isView(u)
-  }
-}

package/test/integration/defaultConfigurationManager.spec.ts

@@ -1,85 +0,0 @@
-import { DefaultConfigurationManager } from '../../src/configurationManager/defaultConfigurationManager'
-import { readFileSync, existsSync } from 'fs'
-import { TextEncoder, TextDecoder } from 'util'
-
-global.TextEncoder = TextEncoder
-global.TextDecoder = TextDecoder
-
-describe('configuration manager', () => {
-  const configFilePath = 'config/sudoplatformconfig.json'
-  if (existsSync(configFilePath)) {
-    const config = readFileSync(configFilePath, 'utf-8')
-    const json = JSON.parse(config)
-
-    describe('validateConfig', () => {
-      it('should return deprecated service info if equal to deprecated version', async () => {
-        const config = {
-          identityService: {
-            region: json.identityService.region,
-            serviceInfoBucket: json.identityService.serviceInfoBucket,
-          },
-          vcService: {
-            version: 3,
-          },
-        }
-
-        const manager = DefaultConfigurationManager.getInstance().setConfig(
-          JSON.stringify(config),
-        )
-
-        await expect(manager.validateConfig()).resolves.toEqual({
-          deprecated: [
-            {
-              configVersion: 3,
-              minSupportedVersion: 2,
-              deprecatedVersion: 3,
-              name: 'vcService',
-            },
-          ],
-          incompatible: [],
-        })
-      })
-
-      it('should return incompatible service info if less than min version', async () => {
-        const config = {
-          identityService: {
-            region: json.identityService.region,
-            serviceInfoBucket: json.identityService.serviceInfoBucket,
-          },
-          vcService: {
-            version: 1,
-          },
-        }
-
-        const manager = DefaultConfigurationManager.getInstance().setConfig(
-          JSON.stringify(config),
-        )
-
-        await expect(manager.validateConfig()).resolves.toEqual({
-          deprecated: [
-            {
-              configVersion: 1,
-              minSupportedVersion: 2,
-              deprecatedVersion: 3,
-              name: 'vcService',
-            },
-          ],
-          incompatible: [
-            {
-              configVersion: 1,
-              minSupportedVersion: 2,
-              deprecatedVersion: 3,
-              name: 'vcService',
-            },
-          ],
-        })
-      })
-    })
-  } else {
-    it('Skip all tests.', () => {
-      console.log(
-        'No sudoplatformconfig.json, test key and test key ID file found. Skipping all integration tests.',
-      )
-    })
-  }
-})

package/test/matchers.ts

@@ -1,122 +0,0 @@
-export {}
-
-function match(
-  context: jest.MatcherContext,
-  caught: Error,
-  error: {
-    name: string | RegExp | undefined
-    message?: string | RegExp | undefined | null
-  },
-): { pass: boolean; message: () => string } {
-  const failures: string[] = []
-  if (caught) {
-    if (error.name instanceof RegExp) {
-      let pass: boolean
-      if (
-        caught.name !== undefined &&
-        caught.name !== null &&
-        typeof caught.name === 'string'
-      ) {
-        pass = error.name.exec(caught.name) != null
-      } else {
-        pass = false
-      }
-      if (!pass) {
-        failures.push(
-          `name '${caught.name}' does not match regexp ${error.name.source}`,
-        )
-      }
-    } else if (error.name !== undefined) {
-      if (caught.name !== error.name) {
-        failures.push(`name '${caught.name}' does not match '${error.name}'`)
-      }
-    }
-
-    if (error.message instanceof RegExp) {
-      let pass: boolean
-      if (
-        caught.message !== undefined &&
-        caught.message !== null &&
-        typeof caught.message === 'string'
-      ) {
-        pass = error.message.exec(caught.message) != null
-      } else {
-        pass = false
-      }
-      if (!pass) {
-        failures.push(
-          `message '${caught.message}' does not match regexp ${error.message.source}`,
-        )
-      }
-    } else if (error.message !== undefined) {
-      if (caught.message !== error.message) {
-        failures.push(
-          `message '${caught.message} does not match '${error.message}'`,
-        )
-      }
-    }
-  } else {
-    failures.push(`no error thrown`)
-  }
-
-  if (failures.length === 0 || context.isNot) {
-    return {
-      pass: true,
-      message: () => 'matched',
-    }
-  } else {
-    if (context.isNot) {
-      failures.push(`expected ${caught} not to match ${error} but does`)
-    }
-
-    return {
-      pass: false,
-      message: () => {
-        return `Failures: ${JSON.stringify(failures, undefined, 2)}`
-      },
-    }
-  }
-}
-
-declare global {
-  namespace jest {
-    interface Matchers<R> {
-      toThrowErrorMatching(error: {
-        name: string | RegExp | undefined | null
-        message?: string | RegExp | undefined | null
-      }): R
-      toMatchError(error: {
-        name: string | RegExp | undefined | null
-        message?: string | RegExp | undefined | null
-      }): R
-    }
-  }
-}
-
-expect.extend({
-  toThrowErrorMatching(
-    operation: () => unknown,
-    error: {
-      name: string | RegExp | undefined
-      message?: string | RegExp | undefined | null
-    },
-  ) {
-    let caught: Error | undefined
-    try {
-      operation()
-    } catch (err) {
-      caught = err
-    }
-
-    return match(this, caught, error)
-  },
-  toMatchError(
-    caught: Error,
-    error: {
-      name: string | RegExp | undefined
-      message?: string | RegExp | undefined | null
-    },
-  ) {
-    return match(this, caught, error)
-  },
-})