@api-client/core 0.6.4 → 0.6.7

package/src/authorization/lib/Utils.ts

@@ -0,0 +1,89 @@
+/**
+ * Normalizes type name to a string identifier.
+ * It casts input to a string and lowercase it.
+ * @param type Type value
+ * @return Normalized value.
+ */
+export const normalizeType = (type?: string): string => String(type).toLowerCase();
+
+export const METHOD_BASIC = "basic";
+export const METHOD_BEARER = "bearer";
+export const METHOD_NTLM = "ntlm";
+export const METHOD_DIGEST = "digest";
+export const METHOD_OAUTH2 = "oauth 2";
+export const METHOD_OIDC = "open id";
+export const METHOD_CC = 'client certificate';
+export const CUSTOM_CREDENTIALS = "Custom credentials";
+
+/**
+ * @param value The value to validate
+ * @returns True if the redirect URI can be considered valid.
+ */
+export function validateRedirectUri(value: unknown): boolean {
+  let result = true;
+  if (!value || typeof value !== 'string') {
+    result = false;
+  }
+  // the redirect URI can have any value, especially for installed apps which 
+  // may use custom schemes. We do very basic sanity check for any script content 
+  // validation to make sure we are not passing any script.
+  if (result && String(value).startsWith('javascript:')) {
+    result = false;
+  }
+  return result;
+}
+
+/**
+ * Generates client nonce for Digest authorization.
+ *
+ * @return Generated client nonce.
+ */
+export function generateCnonce(): string {
+  const characters = 'abcdef0123456789';
+  let token = '';
+  for (let i = 0; i < 16; i++) {
+    const randNum = Math.round(Math.random() * characters.length);
+    token += characters.substring(randNum, 1);
+  }
+  return token;
+}
+
+/**
+ * Generates `state` parameter for the OAuth2 call.
+ *
+ * @return Generated state string.
+ */
+export function generateState(): string {
+  let text = '';
+  const possible = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+  for (let i = 0; i < 6; i++) {
+    text += possible.charAt(Math.floor(Math.random() * possible.length));
+  }
+  return text;
+}
+
+/**
+ * When defined and the `url` is a relative path staring with `/` then it
+ * adds base URI to the path and returns concatenated value.
+ *
+ * @param url The URL to process
+ * @param baseUri Base URI to use.
+ * @returns Final URL value.
+ */
+export function readUrlValue(url?: string, baseUri?: string): string {
+  if (!url) {
+    return '';
+  }
+  const result = String(url);
+  if (!baseUri) {
+    return result;
+  }
+  if (result[0] === '/') {
+    let uri = baseUri;
+    if (uri[uri.length - 1] === '/') {
+      uri = uri.substring(0, uri.length - 1);
+    }
+    return `${uri}${result}`;
+  }
+  return result;
+}

package/src/lib/transformers/PayloadSerializer.ts

@@ -1,3 +1,5 @@
+import { hasBlob, hasBuffer, hasFormData } from '../../Platform.js';
+
 export type PayloadTypes = 'string' | 'file' | 'blob' | 'buffer' | 'arraybuffer' | 'formdata' | 'x-www-form-urlencoded';
 export type DeserializedPayload = string | Blob | File | FormData | Buffer | ArrayBuffer | undefined;
 export const SupportedPayloadTypes: PayloadTypes[] = ['string', 'file', 'blob', 'buffer', 'arraybuffer', 'formdata', 'x-www-form-urlencoded'];
@@ -86,10 +88,6 @@ export interface ISafePayload {
  */
 export type Payload = string | ISafePayload;
 
-export const hasFormData: boolean = typeof FormData === 'function';
-export const hasBlob: boolean = typeof Blob === 'function';
-export const hasBuffer: boolean = typeof Buffer === 'function';
-
 export class PayloadSerializer {
   /**
    * Checked whether the passed payload can be safely stored in the data store.

package/src/models/SerializablePayload.ts

@@ -1,4 +1,5 @@
-import { PayloadSerializer, Payload, DeserializedPayload, hasBuffer } from '../lib/transformers/PayloadSerializer.js';
+import { PayloadSerializer, Payload, DeserializedPayload } from '../lib/transformers/PayloadSerializer.js';
+import { hasBuffer } from '../Platform.js';
 
 export class SerializablePayload {
   /**

package/src/models/data/DataAssociation.ts

@@ -0,0 +1,189 @@
+import v4 from '../../lib/uuid.js';
+import { IThing, Thing } from "../Thing.js";
+import { IDataAssociationSchema } from './DataAssociationSchema.js';
+import { DataEntity } from './DataEntity.js';
+import { DataNamespace } from './DataNamespace.js';
+
+export const Kind = 'Core#DataAssociation';
+
+export interface IDataAssociation {
+  kind: typeof Kind;
+  /**
+   * The key of the namespace.
+   */
+  key: string;
+  /**
+   * The data association description.
+   */
+  info: IThing;
+  /**
+   * Wether the data association is required.
+   */
+  required?: boolean;
+  /**
+   * Whether the data association allows multiple items.
+   */
+  multiple?: boolean;
+  /**
+   * The target entity of this association.
+   * An association without a target is considered invalid and discarded when processing the values.
+   */
+  target?: string;
+  /**
+   * The schema allowing to translate the model into a specific format (like JSON, RAML, XML, etc.)
+   */
+  schema?: IDataAssociationSchema;
+}
+
+export class DataAssociation {
+  kind = Kind;
+
+  key = '';
+
+  /**
+   * The description of the data namespace.
+   */
+  info: Thing = Thing.fromName('');
+
+  /**
+   * Wether the data association is required.
+   */
+  required?: boolean;
+
+  /**
+   * Whether the data association allows multiple items.
+   */
+  multiple?: boolean;
+
+  /**
+   * The target entity of this association.
+   * An association without a target is considered invalid and discarded when processing the values.
+   */
+  target?: string;
+
+  /**
+   * The schema allowing to translate the model into a specific format (like JSON, RAML, XML, etc.)
+   * 
+   * Implementation note, when an entity is removed this property is not changed. The target can't 
+   * be read but it can be tracked to a deleted entity.
+   */
+  schema?: IDataAssociationSchema;
+
+  static fromTarget(root: DataNamespace, target: string): DataAssociation {
+    const assoc = new DataAssociation(root);
+    assoc.target = target;
+    return assoc;
+  }
+
+  static fromName(root: DataNamespace, name: string): DataAssociation {
+    const assoc = new DataAssociation(root);
+    assoc.info = Thing.fromName(name);
+    return assoc;
+  }
+
+  /**
+   * @param input The data association definition to restore.
+   */
+  constructor(protected root: DataNamespace, input?: string | IDataAssociation) {
+    let init: IDataAssociation;
+    if (typeof input === 'string') {
+      init = JSON.parse(input);
+    } else if (typeof input === 'object') {
+      init = input;
+    } else {
+      init = {
+        kind: Kind,
+        key: v4(),
+        info: Thing.fromName('').toJSON(),
+      };
+    }
+    this.new(init);
+  }
+
+  new(init: IDataAssociation): void {
+    if (!DataAssociation.isDataAssociation(init)) {
+      throw new Error(`Not a data association.`);
+    }
+    const { info, key = v4(), kind = Kind, schema, multiple, required, target } = init;
+    this.kind = kind;
+    this.key = key;
+    if (info) {
+      this.info = new Thing(info);
+    } else {
+      this.info = Thing.fromName('');
+    }
+    if (schema) {
+      this.schema = { ...schema };
+    } else {
+      this.schema = undefined;
+    }
+    if (typeof multiple === 'boolean') {
+      this.multiple = multiple;
+    } else {
+      this.multiple = undefined;
+    }
+    if (typeof required === 'boolean') {
+      this.required = required;
+    } else {
+      this.required = undefined;
+    }
+    if (typeof target === 'string') {
+      this.target = target;
+    } else {
+      this.target = undefined;
+    }
+  }
+
+  static isDataAssociation(input: unknown): boolean {
+    const typed = input as IDataAssociation;
+    if (!input || typed.kind !== Kind) {
+      return false;
+    }
+    return true;
+  }
+
+  toJSON(): IDataAssociation {
+    const result: IDataAssociation = {
+      kind: Kind,
+      key: this.key,
+      info: this.info.toJSON(),
+    };
+    if (this.schema) {
+      result.schema = { ...this.schema };
+    }
+    if (typeof this.multiple === 'boolean') {
+      result.multiple = this.multiple;
+    }
+    if (typeof this.required === 'boolean') {
+      result.required = this.required;
+    }
+    if (typeof this.target === 'string') {
+      result.target = this.target;
+    }
+    return result;
+  }
+
+  getTarget(): DataEntity | undefined {
+    const { root, target } = this;
+    if (!target) {
+      return undefined;
+    }
+    return root.definitions.entities.find(i => i.key === target);
+  }
+
+  /**
+   * Removes self from the parent entity and the namespace definition.
+   */
+  remove(): void {
+    const { root } = this;
+    const entity = root.definitions.entities.find(i => i.associations.some(j => j === this));
+    if (entity) {
+      const assocIndex = entity.associations.findIndex(i => i === this);
+      entity.associations.splice(assocIndex, 1);
+    }
+    const defIndex = this.root.definitions.associations.findIndex(i => i.key === this.key);
+    if (defIndex >= 0) {
+      this.root.definitions.associations.splice(defIndex, 1);
+    }
+  }
+}

package/src/models/data/DataAssociationSchema.ts

@@ -0,0 +1,32 @@
+export interface IDataAssociationSchema {
+  /**
+   * Whether the target entity should be embedded under the property name.
+   * When false, this association is just an information that one entity depend on another.
+   * When true, it changes the definition of the schema having this association to 
+   * add the target schema properties inline with this property.
+   * 
+   * **When true**
+   * 
+   * ```javascript
+   * // generated schema for `address` association
+   * {
+   *  "name": "example value",
+   *  "address": {
+   *    "city": "example value",
+   *    ...
+   *  }
+   * }
+   * ```
+   * 
+   * **When false**
+   * 
+   * ```javascript
+   * // generated schema for `address` association
+   * {
+   *  "name": "example value",
+   *  "address": "the key of the referenced schema"
+   * }
+   * ```
+   */
+  embedded?: boolean;
+}