@fairandsmart/consents-ce 1.3.7

package/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 fairandsmart
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,116 @@
+# Fair&Smart Right Consents TypeScript support
+
+This project implements TypeScript definitions and API helpers for the [Fair&Smart Right Consents API](https://cmback.dev.env.fairandsmart.tech/swagger-ui/). It's meant for use in [Right Consents Front-end](https://github.com/fairandsmart/consent-manager-lib-ce), but should be general enough to use in any project. The code is maintained and based on the [Right Consents Back-end](https://github.com/fairandsmart/consent-manager-back) API resources and models, to be as close as possible to the true representation of the resources.
+
+# Install
+
+```
+npm i @fairandsmart/consents-ce
+```
+
+# Interfaces and Enums
+
+All the interface type definitions and enums are for type info only - everything will compile out. Only the API helpers produce real JavaScript output. You can import types from each service defined on [the API](https://cmback.dev.env.fairandsmart.tech/swagger-ui/):
+
+```typescript
+import { ModelVersionDtoLight, ModelsResource } from '@fairandsmart/consents-ce/models';
+```
+
+
+# API Helpers
+
+In addition to the types, there are also simple helper functions for each API endpoint. They define the inputs and outputs to that endpoint, and will call a user-provided function with HTTP request info that you can then use to make an HTTP request. This pattern was used so the API helpers could provide full type information. These helpers are not a full API client - they assist in building one. An example:
+
+```typescript
+import { RcHttpClientConfig } from '@fairandsmart/consents-ce';
+
+function http(config: RcHttpClientConfig): Observable<ModelEntryDto> {
+    // fill in the API key, handle OAuth, etc., then make an HTTP request using the config.
+    return fromFetch(config.url, ...);
+}
+
+// Use either as an observable
+
+ModelsResource.getEntry(entryId).subscribe((modelEntry: ModelEntryDto) => {
+    ...  
+});
+
+// ... or a promise using the .toPromise method
+
+const modelEntry: ModelEntryDto = await ModelsResource.getEntry(entryId).toPromise();
+```
+
+Note that the API Helpers all return Observables and not promises. Feel free to adapt the behavior as you see fit.
+
+To setup the helpers properly, see the Initialization section below.
+
+
+# Initialization
+
+*Note: this is not required if you only want to use the library for type descriptions*
+
+If you wish to use the API helpers, you need to initialize the library in your project:
+
+```typescript
+import { RightConsents } from '@fairandsmart/consents-ce';
+
+RightConsents.init({
+    apiRoot: 'http://localhost:4287',
+    httpClient: myCustomHttpClient // see API Helpers for more details
+})
+```
+
+You need to provide the endpoint at which the API is available, and a custom HttpClient to handle all the requests.
+
+
+# Imports
+
+It is possible to import all services from `@fairandsmart/consent-manager` directly, but it's better to use the direct import:
+
+```typescript
+// good
+import { getEntry } from '@fairandsmart/consents-ce/models';
+getEntry(...);
+
+// works, but not as good. Use for disambiguity if needed
+import { ModelsResources } from '@fairandsmart/consents-ce';
+ModelsResources.getEntry(...);
+```
+
+# Model Helpers
+
+Some imports also contains helpers for parsing and interpreting the resources:
+
+```typescript
+import { map } from 'rxjs';
+import { ModelEntryDto, ModelEntryHelper, getEntry } from '@fairandsmart/consents-ce/models';
+
+getEntry(modelId).pipe(
+    map((entry: ModelEntryDto) => ModelEntryHelper.getActiveVersion(entry))
+).subscribe((activeVersion) => {
+    // ModelEntryHelper is an object with static methods to help you parse the entry. 
+    // In this example, you can find the active version of a model
+    ... 
+});
+```
+
+# Build
+
+```
+# build
+npm run build
+# pack for local import
+npm run pack
+# install local version in a different project
+npm i {lib-repository}/lib/fairandsmart-consents-ce-{VERSION}.tgz
+```
+
+# Contribute 
+
+- Create a branch for your work (PRD-XXX)
+- Upgrade the version in the package-lib.json
+- Add your work
+- Run `.build.sh` and push 
+- Create a new merge request
+
+

package/api.d.ts

@@ -0,0 +1,19 @@
+import { RcHttpClient } from './http';
+export interface RightConsentsApiConfig {
+    httpClient: RcHttpClient;
+    apiRoot: string;
+}
+declare class RightConsentsApi {
+    private _config;
+    /**
+     * Returns the http client setup in the init function. If none are present, warns the user and returns default handler
+     */
+    get http(): RcHttpClient;
+    get config(): RightConsentsApiConfig;
+    get initialized(): boolean;
+    constructor();
+    init(config: RightConsentsApiConfig): void;
+    reset(): void;
+}
+export declare const RightConsents: RightConsentsApi;
+export {};

package/api.js

@@ -0,0 +1,67 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RightConsents = void 0;
+var http_1 = require("./http");
+var RightConsentsApi = /** @class */ (function () {
+    function RightConsentsApi() {
+        // @ts-ignore
+        this._config = {
+            httpClient: http_1.defaultHttpClient,
+            apiRoot: 'no_endpoint',
+            default: true
+        };
+    }
+    Object.defineProperty(RightConsentsApi.prototype, "http", {
+        /**
+         * Returns the http client setup in the init function. If none are present, warns the user and returns default handler
+         */
+        get: function () {
+            if (!this._config || this._config.default) {
+                console.warn('No HTTP client was registered in `@fairandsmart/consents-ce`');
+            }
+            return this._config.httpClient;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(RightConsentsApi.prototype, "config", {
+        get: function () {
+            if (!this._config || this._config.default) {
+                console.warn('You must call RightConsents.init before you can use the API features of `@fairandsmart/consents-ce` ');
+            }
+            return this._config;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(RightConsentsApi.prototype, "initialized", {
+        get: function () {
+            return !this._config.default && !!this._config.httpClient && this._config.apiRoot !== 'no_endpoint';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    RightConsentsApi.prototype.init = function (config) {
+        this._config = __assign(__assign(__assign({}, this._config), config), { default: false });
+    };
+    RightConsentsApi.prototype.reset = function () {
+        this._config = {
+            httpClient: http_1.defaultHttpClient,
+            apiRoot: 'no_endpoint',
+            default: true
+        };
+    };
+    return RightConsentsApi;
+}());
+exports.RightConsents = new RightConsentsApi();

package/common.d.ts

@@ -0,0 +1,8 @@
+export interface CollectionPage<T> {
+    values: T[];
+    page: number;
+    pageSize: number;
+    totalPages: number;
+    totalCount: number;
+}
+export declare type SortDirection = 'asc' | 'desc' | '';

package/common.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/consents/api.d.ts

@@ -0,0 +1,9 @@
+import { Observable } from 'rxjs';
+import { ConsentContext } from './interfaces';
+import { RCApiOptions } from '../http';
+export declare function createTransactionJson(ctx: ConsentContext, lang: string, options?: RCApiOptions): Observable<string>;
+export declare function getTransactionJson(transactionId: string, options?: RCApiOptions): Observable<string>;
+export declare function postSubmissionValuesHtml(txid: string, values: {
+    [key: string]: string;
+}, options?: RCApiOptions): Observable<string>;
+export declare function getSubmitFormPreview(ctx: ConsentContext, lang: string, options?: RCApiOptions): Observable<string>;

package/consents/api.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSubmitFormPreview =
+  exports.postSubmissionValuesHtml =
+  exports.getTransactionJson =
+  exports.createTransactionJson =
+    void 0;
+var api_1 = require("../api");
+function createTransactionJson(ctx, lang, options) {
+  return api_1.RightConsents.http({
+    method: "POST",
+    url: "".concat(api_1.RightConsents.config.apiRoot, "/consents"),
+    body: ctx,
+    responseType: "text",
+    resolveHeaders: true,
+    headers: {
+      "Content-Type": "application/json",
+      "Accept-Language": lang,
+    },
+    options: options,
+  });
+}
+exports.createTransactionJson = createTransactionJson;
+function getTransactionJson(transactionId, options) {
+  return api_1.RightConsents.http({
+    method: "GET",
+    url: ""
+      .concat(api_1.RightConsents.config.apiRoot, "/consents/")
+      .concat(transactionId),
+    headers: {
+      "Content-Type": "application/json",
+    },
+    options: options,
+  });
+}
+exports.getTransactionJson = getTransactionJson;
+function postSubmissionValuesHtml(txid, values, options) {
+  return api_1.RightConsents.http({
+    method: "POST",
+    url: ""
+      .concat(api_1.RightConsents.config.apiRoot, "/consents/")
+      .concat(txid, "/submit"),
+    body: Object.keys(values)
+      .map(function (key) {
+        return "".concat(key, "=").concat(encodeURIComponent(values[key]));
+      })
+      .join("&"),
+    responseType: "text",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
+    },
+    options: options,
+  });
+}
+exports.postSubmissionValuesHtml = postSubmissionValuesHtml;
+function getSubmitFormPreview(ctx, lang, options) {
+  return api_1.RightConsents.http({
+    method: "POST",
+    url: "".concat(api_1.RightConsents.config.apiRoot, "/consents/preview"),
+    body: ctx,
+    responseType: "text",
+    headers: {
+      "Content-Type": "application/json",
+      "Accept-Language": lang,
+    },
+    options: options,
+  });
+}
+exports.getSubmitFormPreview = getSubmitFormPreview;

package/consents/helpers.d.ts

@@ -0,0 +1,6 @@
+import { RecordDto } from '../records';
+import { ConsentContext } from './interfaces';
+import { ModelEntryDto } from '../models';
+export declare class ConsentHelper {
+    static generateContextFromRecord(entry: ModelEntryDto, record: RecordDto, lang?: string): ConsentContext;
+}

package/consents/helpers.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsentHelper = void 0;
+var models_1 = require("../models");
+var ConsentHelper = /** @class */ (function () {
+  function ConsentHelper() {}
+  ConsentHelper.generateContextFromRecord = function (entry, record, lang) {
+    if (lang === void 0) {
+      lang = entry.defaultLanguage;
+    }
+    return {
+      language: lang,
+      subject: record.subject,
+      origin: models_1.ConsentOrigin.USER,
+      layoutData: {
+        info: "",
+        elements: [entry.key],
+        type: "layout",
+      },
+    };
+  };
+  return ConsentHelper;
+})();
+exports.ConsentHelper = ConsentHelper;

package/consents/index.d.ts

@@ -0,0 +1,3 @@
+export * from './interfaces';
+export * from './api';
+export * from './helpers';

package/consents/index.js

@@ -0,0 +1,35 @@
+"use strict";
+var __createBinding =
+  (this && this.__createBinding) ||
+  (Object.create
+    ? function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        var desc = Object.getOwnPropertyDescriptor(m, k);
+        if (
+          !desc ||
+          ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)
+        ) {
+          desc = {
+            enumerable: true,
+            get: function () {
+              return m[k];
+            },
+          };
+        }
+        Object.defineProperty(o, k2, desc);
+      }
+    : function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        o[k2] = m[k];
+      });
+var __exportStar =
+  (this && this.__exportStar) ||
+  function (m, exports) {
+    for (var p in m)
+      if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p))
+        __createBinding(exports, m, p);
+  };
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./interfaces"), exports);
+__exportStar(require("./api"), exports);
+__exportStar(require("./helpers"), exports);

package/consents/interfaces.d.ts

@@ -0,0 +1,74 @@
+import { ConsentOrigin, FormLayout } from '../models';
+export declare enum Confirmation {
+    NONE = "NONE",
+    FORM_CODE = "FORM_CODE",
+    EMAIL_CODE = "EMAIL_CODE",
+    SMS_CODE = "SMS_CODE",
+    SIGNATURE = "SIGNATURE",
+    AUDIO_RECORD = "AUDIO_RECORD",
+    VIDEO_RECORD = "VIDEO_RECORD",
+    DIGITAL_SIGNATURE = "DIGITAL_SIGNATURE"
+}
+export declare const CONFIRMATION_TYPES: Confirmation[];
+export declare enum UserInfosKeys {
+    EMAIL_KEY = "emailAddress",
+    PHONE_KEY = "phoneNumber"
+}
+export declare enum ConfirmationConfigKeys {
+    SENDER_EMAIL_KEY = "senderEmail",
+    SENDER_PHONE_KEY = "senderPhone"
+}
+/**
+ * The ConsentContext is used to generate a token. This token is used:
+ * - To generate a form in a browser for the user to fill
+ * - To collect the consent of a user through the API
+ */
+export interface ConsentContext {
+    /** The identifier of the profile the processing will be linked to */
+    subject: string;
+    /** If the form is not in iframe mode, the user will be redirected to this callback once the process is over */
+    callback?: string;
+    /** If the IFrame mode is set, set the allowed origin for the parent window domain */
+    iframeOrigin?: string;
+    /** The language of the form. All models must have a valid version of this language for the form to display properly */
+    language: string;
+    /** Specifies the consent origin (what was the collecting support). Either:
+     * webform (the user used a form)
+     * or operator (a competent authority filled the form)
+     */
+    origin?: ConsentOrigin;
+    /** (optional) The ISO 8601 duration for the validity of the record.  */
+    validity?: string;
+    /** Specifies whether the consent can be updated afterwards. */
+    updatable?: boolean;
+    /** Any relevant informations about the user that will be persisted in the receipt */
+    userinfos?: {
+        [key: string]: string;
+    };
+    /** Any other relevant informations about the context that will be persisted in the record */
+    attributes?: {
+        [key: string]: string;
+    };
+    /** (readonly) A transaction identifier for that consent.  */
+    transaction?: string;
+    /** The identifier of the user who used the form */
+    author?: string;
+    /** The FormLayout Data to use ; if layout key is provided, layoutData will be ignored.*/
+    layoutData?: FormLayout;
+    /** The reference to the 'formlayout' model that will be used.*/
+    layout?: string;
+    /** The type of user confirmation needed, default is NONE */
+    confirmation?: Confirmation;
+    /** Additional information needed for user confirmation */
+    confirmationConfig?: {
+        [key: string]: string;
+    };
+}
+/** Used to generate a Receipt from a transaction id */
+export interface ConsentTransaction {
+    subject: string;
+    transaction: string;
+    claims: {
+        [key: string]: string;
+    };
+}

package/consents/interfaces.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfirmationConfigKeys =
+  exports.UserInfosKeys =
+  exports.CONFIRMATION_TYPES =
+  exports.Confirmation =
+    void 0;
+var Confirmation;
+(function (Confirmation) {
+  Confirmation["NONE"] = "NONE";
+  Confirmation["FORM_CODE"] = "FORM_CODE";
+  Confirmation["EMAIL_CODE"] = "EMAIL_CODE";
+  Confirmation["SMS_CODE"] = "SMS_CODE";
+  Confirmation["SIGNATURE"] = "SIGNATURE";
+  Confirmation["AUDIO_RECORD"] = "AUDIO_RECORD";
+  Confirmation["VIDEO_RECORD"] = "VIDEO_RECORD";
+  Confirmation["DIGITAL_SIGNATURE"] = "DIGITAL_SIGNATURE";
+})((Confirmation = exports.Confirmation || (exports.Confirmation = {})));
+exports.CONFIRMATION_TYPES = Object.keys(Confirmation);
+var UserInfosKeys;
+(function (UserInfosKeys) {
+  UserInfosKeys["EMAIL_KEY"] = "emailAddress";
+  UserInfosKeys["PHONE_KEY"] = "phoneNumber";
+})((UserInfosKeys = exports.UserInfosKeys || (exports.UserInfosKeys = {})));
+var ConfirmationConfigKeys;
+(function (ConfirmationConfigKeys) {
+  ConfirmationConfigKeys["SENDER_EMAIL_KEY"] = "senderEmail";
+  ConfirmationConfigKeys["SENDER_PHONE_KEY"] = "senderPhone";
+})(
+  (ConfirmationConfigKeys =
+    exports.ConfirmationConfigKeys || (exports.ConfirmationConfigKeys = {}))
+);

package/css-autocomplete.d.ts

@@ -0,0 +1,14 @@
+interface HintEntry {
+    value: string;
+    context: {
+        [key: string]: string;
+    };
+    position: {
+        [key: string]: string;
+    };
+    description?: {
+        [key: string]: string;
+    };
+}
+export declare const CSS_HINTS: HintEntry[];
+export {};