@hahnpro/hpc-api 5.3.4 → 2024.4.0-0

package/{dist → src/lib}/task.service.d.ts

@@ -1,6 +1,6 @@
 import { APIBase } from './api-base';
 import { DataService } from './data.service';
-import { HttpClient } from './http.service';
+import { HttpClient, TokenOption } from './http.service';
 import { Task } from './task.interface';
 import { TrashService } from './trash.service';
 interface BaseService extends DataService<Task>, TrashService<Task> {
@@ -9,6 +9,6 @@ declare class BaseService extends APIBase {
 }
 export declare class TaskService extends BaseService {
     constructor(httpClient: HttpClient);
-    createTaskAttachedToAsset(dto: any): Promise<Task>;
+    createTaskAttachedToAsset(dto: any, options?: TokenOption): Promise<Task>;
 }
 export {};

package/src/lib/task.service.js

@@ -0,0 +1,19 @@
+import { __decorate } from "tslib";
+import { mix } from 'ts-mixer';
+import { APIBase } from './api-base';
+import { DataService } from './data.service';
+import { TrashService } from './trash.service';
+let BaseService = class BaseService extends APIBase {
+};
+BaseService = __decorate([
+    mix(DataService, TrashService)
+], BaseService);
+export class TaskService extends BaseService {
+    constructor(httpClient) {
+        super(httpClient, '/tasks');
+    }
+    // we may not need this method (already have the addOne method from DataService)
+    createTaskAttachedToAsset(dto, options = {}) {
+        return this.httpClient.post(this.basePath, dto, options);
+    }
+}

package/src/lib/timeseries.interface.js

@@ -0,0 +1 @@
+export {};

package/{dist → src/lib}/timeseries.service.d.ts

@@ -1,7 +1,7 @@
 import { APIBase } from './api-base';
 import { Paginated } from './data.interface';
 import { DataService } from './data.service';
-import { HttpClient } from './http.service';
+import { HttpClient, TokenOption } from './http.service';
 import { TimeSeries, TimeSeriesValue, TS_GROUPS } from './timeseries.interface';
 import { TrashService } from './trash.service';
 interface BaseService extends DataService<TimeSeries>, TrashService<TimeSeries> {
@@ -12,7 +12,7 @@ export declare class TimeSeriesService extends BaseService {
     constructor(httpClient: HttpClient);
     addValue(id: string, value: {
         [timestamp: string]: any;
-    }): Promise<void>;
+    }, options?: TokenOption): Promise<void>;
     /**
      * Adds time series values to an asset by the name of the time series.
      * If the time series does not exist, it is created.
@@ -25,11 +25,12 @@ export declare class TimeSeriesService extends BaseService {
      *   [timestamp: string]: any, // The timestamp and value pairs
      *   ...
      * }
+     * @param options
      * @returns a promise that resolves to the time series that was added.
      */
     addAssetTimeSeriesValues(assetId: string, name: string, readPermissions: string[], readWritePermissions: string[], values: {
         [timestamp: string]: any;
-    }): Promise<TimeSeries>;
+    }, options?: TokenOption): Promise<TimeSeries>;
     /**
      * Adds multiple time series values to an asset by the name of the time series.
      * If the time series does not exist, it is created.
@@ -46,6 +47,7 @@ export declare class TimeSeriesService extends BaseService {
      *  },
      *  ...
      * }
+     * @param options
      * @returns a promise that resolves to an array of objects containing the results of the operation.
      * Each object has the following structure:
      * {
@@ -58,10 +60,10 @@ export declare class TimeSeriesService extends BaseService {
         [timeSeriesName: string]: {
             [timestamp: string]: any;
         };
-    }): Promise<PromiseSettledResult<TimeSeries>[]>;
-    getMostRecentValue(id: string, before?: Date): Promise<TimeSeriesValue>;
-    getValues(id: string, from: number, limit?: number, group?: TS_GROUPS): Promise<TimeSeriesValue[]>;
-    getValuesOfPeriod(id: string, from: number, to: number, group?: TS_GROUPS): Promise<TimeSeriesValue[]>;
-    getManyByAsset(assetId: string, names?: string[]): Promise<Paginated<TimeSeries[]>>;
+    }, options?: TokenOption): Promise<PromiseSettledResult<TimeSeries>[]>;
+    getMostRecentValue(id: string, before?: Date, options?: TokenOption): Promise<TimeSeriesValue>;
+    getValues(id: string, from: number, limit?: number, group?: TS_GROUPS, options?: TokenOption): Promise<TimeSeriesValue[]>;
+    getValuesOfPeriod(id: string, from: number, to: number, group?: TS_GROUPS, options?: TokenOption): Promise<TimeSeriesValue[]>;
+    getManyByAsset(assetId: string, names?: string[], options?: TokenOption): Promise<Paginated<TimeSeries[]>>;
 }
 export {};

package/src/lib/timeseries.service.js

@@ -0,0 +1,92 @@
+import { __decorate } from "tslib";
+import { mix } from 'ts-mixer';
+import { APIBase } from './api-base';
+import { DataService } from './data.service';
+import { TrashService } from './trash.service';
+let BaseService = class BaseService extends APIBase {
+};
+BaseService = __decorate([
+    mix(DataService, TrashService)
+], BaseService);
+export class TimeSeriesService extends BaseService {
+    constructor(httpClient) {
+        super(httpClient, '/tsm');
+    }
+    addValue(id, value, options = {}) {
+        return this.httpClient.post(`${this.basePath}/${id}`, value, options);
+    }
+    /**
+     * Adds time series values to an asset by the name of the time series.
+     * If the time series does not exist, it is created.
+     * @param assetId - The ID of the asset to which the time series values are added.
+     * @param name - The name of the time series.
+     * @param readPermissions - an array of permissions that allow the user to read the time series.
+     * @param readWritePermissions - an array of permissions that allow the user to read and write the time series.
+     * @param values - The time series values are specified as an object with the following structure:
+     * {
+     *   [timestamp: string]: any, // The timestamp and value pairs
+     *   ...
+     * }
+     * @param options
+     * @returns a promise that resolves to the time series that was added.
+     */
+    addAssetTimeSeriesValues(assetId, name, readPermissions, readWritePermissions, values, options = {}) {
+        const dto = {
+            name,
+            readPermissions,
+            readWritePermissions,
+            values,
+        };
+        return this.httpClient.post(`${this.basePath}/assets/${assetId}`, dto, options);
+    }
+    /**
+     * Adds multiple time series values to an asset by the name of the time series.
+     * If the time series does not exist, it is created.
+     * If the operation is successful, the value property contains the time series that was added.
+     * If the operation fails, the reason property contains the error that caused the operation to fail.
+     * @param assetId - The ID of the asset to which the time series values are added.
+     * @param readPermissions - an array of permissions that allow the user to read the time series.
+     * @param readWritePermissions - an array of permissions that allow the user to read and write the time series.
+     * @param timeSeries - The time series values are specified as an object with the following structure:
+     * {
+     *  [timeSeriesName: string]: { // The name of the time series
+     *    [timestamp: string]: any, // The timestamp and value pairs
+     *    ...
+     *  },
+     *  ...
+     * }
+     * @param options
+     * @returns a promise that resolves to an array of objects containing the results of the operation.
+     * Each object has the following structure:
+     * {
+     *  status: "fulfilled" | "rejected",
+     *  value?: TimeSeries,
+     *  reason?: Error,
+     * }
+     */
+    addManyAssetTimeSeriesValues(assetId, readPermissions, readWritePermissions, timeSeries, options = {}) {
+        const dtos = Object.entries(timeSeries).map(([name, values]) => ({
+            name,
+            readPermissions,
+            readWritePermissions,
+            values,
+        }));
+        return this.httpClient.post(`${this.basePath}/assets/${assetId}/bulk`, dtos, options);
+    }
+    getMostRecentValue(id, before, options = {}) {
+        const params = before ? { before: before.toISOString() } : {};
+        return this.httpClient.get(`${this.basePath}/${id}/recent`, { params, ...options });
+    }
+    getValues(id, from, limit, group, options = {}) {
+        const params = { limit, group };
+        return this.httpClient.get(`${this.basePath}/${id}/${from}`, { params, ...options });
+    }
+    getValuesOfPeriod(id, from, to, group, options = {}) {
+        const params = { group };
+        return this.httpClient.get(`${this.basePath}/${id}/${from}/${to}`, { params, ...options });
+    }
+    getManyByAsset(assetId, names, options = {}) {
+        const params = Array.isArray(names) ? { names: names.join() } : {};
+        return this.httpClient.get(`${this.basePath}/asset/${assetId}`, { params, ...options });
+    }
+}

package/{dist → src/lib}/token-set.d.ts

@@ -1,9 +1,11 @@
 export declare class TokenSet {
     private readonly _accessToken;
     private readonly _expiresAt;
-    constructor(access_token: string, expires_in: number);
+    private readonly _provided;
+    constructor(access_token: string, expires_in: number, provided?: boolean);
     get accessToken(): string;
     get expiresAt(): number;
     get expiresIn(): number;
+    get provided(): boolean;
     isExpired(): boolean;
 }

package/src/lib/token-set.js

@@ -0,0 +1,23 @@
+const TOKEN_EXPIRATION_BUFFER = 20; // 20 seconds
+export class TokenSet {
+    constructor(access_token, expires_in, provided = false) {
+        this._accessToken = access_token;
+        this._expiresAt = Math.floor(Date.now() / 1000) + Number(expires_in);
+        this._provided = provided;
+    }
+    get accessToken() {
+        return this._accessToken;
+    }
+    get expiresAt() {
+        return this._expiresAt;
+    }
+    get expiresIn() {
+        return Math.max(this.expiresAt - Math.ceil(Date.now() / 1000), 0);
+    }
+    get provided() {
+        return this._provided;
+    }
+    isExpired() {
+        return this.expiresIn <= (this.provided ? 0 : TOKEN_EXPIRATION_BUFFER); // Use the entire time of provided token to avoid throwing 'expired' error early
+    }
+}

package/{dist → src/lib}/trash.service.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TrashService = void 0;
-const api_base_1 = require("./api-base");
-class TrashService extends api_base_1.APIBase {
+import { APIBase } from './api-base';
+export class TrashService extends APIBase {
     trashRestoreAll() {
         return this.httpClient.put(`${this.basePath}/trash/restore`, {});
     }
@@ -18,4 +15,3 @@ class TrashService extends api_base_1.APIBase {
         return this.httpClient.get(`${this.basePath}/trash`, { params });
     }
 }
-exports.TrashService = TrashService;

package/src/lib/user-settings.interface.js

@@ -0,0 +1 @@
+export {};

package/src/lib/user.service.d.ts

@@ -0,0 +1,11 @@
+import { HttpClient, TokenOption } from './http.service';
+import { UserSettings } from './user-settings.interface';
+export declare class UserService {
+    private httpClient;
+    private readonly basePath;
+    constructor(httpClient: HttpClient);
+    getCurrentUserRoles(): Promise<string[]>;
+    getUserSettings(options?: TokenOption): Promise<UserSettings>;
+    updateUserSettings(settings: UserSettings, options?: TokenOption): Promise<UserSettings>;
+    deleteUserSettings(options?: TokenOption): Promise<UserSettings>;
+}

package/src/lib/user.service.js

@@ -0,0 +1,26 @@
+import { jwtDecode } from 'jwt-decode';
+export class UserService {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+        this.basePath = '/user';
+    }
+    async getCurrentUserRoles() {
+        try {
+            const token = await this.httpClient.getAccessToken();
+            const decode = jwtDecode(token);
+            return decode.realm_access.roles;
+        }
+        catch (err) {
+            return null;
+        }
+    }
+    getUserSettings(options = {}) {
+        return this.httpClient.get(this.basePath, options);
+    }
+    updateUserSettings(settings, options = {}) {
+        return this.httpClient.put(this.basePath, settings, options);
+    }
+    deleteUserSettings(options = {}) {
+        return this.httpClient.delete(this.basePath, options);
+    }
+}

package/src/lib/vault.interface.js

@@ -0,0 +1 @@
+export {};

package/{dist → src/lib}/vault.service.d.ts

@@ -1,7 +1,7 @@
 import { DataService } from './data.service';
+import { HttpClient, TokenOption } from './http.service';
 import { VaultSecret } from './vault.interface';
-import { HttpClient } from './http.service';
 export declare class VaultService extends DataService<VaultSecret> {
     constructor(httpClient: HttpClient);
-    getSecret(name: string, version?: number): Promise<string>;
+    getSecret(name: string, version?: number, options?: TokenOption): Promise<string>;
 }

package/src/lib/vault.service.js

@@ -0,0 +1,10 @@
+import { DataService } from './data.service';
+export class VaultService extends DataService {
+    constructor(httpClient) {
+        super(httpClient, '/vault/secrets');
+    }
+    getSecret(name, version, options = {}) {
+        const params = version ? { version } : {};
+        return this.httpClient.get(`${this.basePath}/${name}/secret`, { params, ...options });
+    }
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2021 Hahn PRO
-
-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/dist/api-base.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.APIBase = void 0;
-class APIBase {
-    constructor(httpClient, basePath) {
-        this.httpClient = httpClient;
-        this.basePath = basePath;
-    }
-}
-exports.APIBase = APIBase;

package/dist/api.js

@@ -1,62 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.API = void 0;
-const asset_service_1 = require("./asset.service");
-const assettypes_service_1 = require("./assettypes.service");
-const content_service_1 = require("./content.service");
-const endpoint_service_1 = require("./endpoint.service");
-const events_service_1 = require("./events.service");
-const http_service_1 = require("./http.service");
-const proxy_service_1 = require("./proxy.service");
-const secret_service_1 = require("./secret.service");
-const task_service_1 = require("./task.service");
-const timeseries_service_1 = require("./timeseries.service");
-const user_service_1 = require("./user.service");
-const flow_service_1 = require("./flow.service");
-const flow_function_service_1 = require("./flow-function.service");
-const flow_module_service_1 = require("./flow-module.service");
-const flow_deployment_service_1 = require("./flow-deployment.service");
-const label_service_1 = require("./label.service");
-const vault_service_1 = require("./vault.service");
-const notification_service_1 = require("./notification.service");
-class API {
-    constructor(httpClient, context) {
-        this.httpClient = httpClient;
-        if (!httpClient) {
-            const normalizePath = (value = '', defaultValue = '') => value.replace(/(?:^\/+)|(?:\/+$)/g, '') || defaultValue;
-            let apiBaseUrl = process.env.API_BASE_URL || 'https://testing.hahnpro.com';
-            if (!apiBaseUrl.startsWith('https') && !apiBaseUrl.startsWith('http')) {
-                console.info('no protocol specified - using HTTPS');
-                apiBaseUrl = `https://${apiBaseUrl}`;
-            }
-            const apiUrl = apiBaseUrl + '/' + normalizePath(process.env.API_BASE_PATH, 'api');
-            const authBaseUrl = process.env.AUTH_BASE_URL || apiBaseUrl;
-            const authUrl = authBaseUrl + '/' + normalizePath(process.env.AUTH_BASE_PATH, 'auth');
-            const realm = process.env.AUTH_REALM || 'hpc';
-            const client = process.env.API_USER || 'flow-executor-service';
-            const secret = process.env.AUTH_SECRET;
-            if (!secret) {
-                throw new Error('"API_BASE_URL", "API_USER", "AUTH_REALM" and "AUTH_SECRET" environment variables must be set');
-            }
-            this.httpClient = new http_service_1.HttpClient(apiUrl, authUrl, realm, client, secret, context === null || context === void 0 ? void 0 : context.tokenSubject);
-        }
-        this.assets = new asset_service_1.AssetService(this.httpClient);
-        this.assetTypes = new assettypes_service_1.AssetTypesService(this.httpClient);
-        this.contents = new content_service_1.ContentService(this.httpClient);
-        this.endpoints = new endpoint_service_1.EndpointService(this.httpClient);
-        this.events = new events_service_1.EventsService(this.httpClient);
-        this.flows = new flow_service_1.FlowService(this.httpClient);
-        this.flowDeployments = new flow_deployment_service_1.FlowDeploymentService(this.httpClient);
-        this.flowFunctions = new flow_function_service_1.FlowFunctionService(this.httpClient);
-        this.flowModules = new flow_module_service_1.FlowModuleService(this.httpClient);
-        this.labels = new label_service_1.LabelService(this.httpClient);
-        this.proxy = new proxy_service_1.ProxyService(this.httpClient);
-        this.secrets = new secret_service_1.SecretService(this.httpClient);
-        this.tasks = new task_service_1.TaskService(this.httpClient);
-        this.timeSeries = new timeseries_service_1.TimeSeriesService(this.httpClient);
-        this.users = new user_service_1.UserService(this.httpClient);
-        this.vault = new vault_service_1.VaultService(this.httpClient);
-        this.notifications = new notification_service_1.NotificationService(this.httpClient);
-    }
-}
-exports.API = API;

package/dist/asset.interface.js

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

package/dist/asset.service.d.ts

@@ -1,24 +0,0 @@
-import FormData from 'form-data';
-import { APIBase } from './api-base';
-import { Asset, AssetRevision, Attachment, EventCause, EventLevelOverride } from './asset.interface';
-import { Paginated, RequestParameter } from './data.interface';
-import { DataService } from './data.service';
-import { HttpClient } from './http.service';
-import { TrashService } from './trash.service';
-interface BaseService extends DataService<Asset>, TrashService<Asset> {
-}
-declare class BaseService extends APIBase {
-}
-export declare class AssetService extends BaseService {
-    constructor(httpClient: HttpClient);
-    deleteOne(id: string, force?: boolean): Promise<any>;
-    addAttachment: (id: string, form: FormData) => Promise<Asset>;
-    getChildren(assetId: string, params?: RequestParameter): Promise<Paginated<Asset[]>>;
-    getAttachments(assetId: string): Promise<Paginated<Attachment[]>>;
-    getEventLevelOverride(ids: string[], causes: string[]): Promise<EventLevelOverride>;
-    updateEventCausesAsset(id: string, dto: EventCause): Promise<Asset>;
-    getRevisions(assetId: string): Promise<Paginated<AssetRevision[]>>;
-    rollback(assetId: string, revisionId: string): Promise<Asset>;
-    deleteRevision(assetId: string, revisionId: string): Promise<any>;
-}
-export {};

package/dist/asset.service.js

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AssetService = void 0;
-const tslib_1 = require("tslib");
-const ts_mixer_1 = require("ts-mixer");
-const api_base_1 = require("./api-base");
-const data_service_1 = require("./data.service");
-const trash_service_1 = require("./trash.service");
-let BaseService = class BaseService extends api_base_1.APIBase {
-};
-BaseService = tslib_1.__decorate([
-    (0, ts_mixer_1.mix)(data_service_1.DataService, trash_service_1.TrashService)
-], BaseService);
-class AssetService extends BaseService {
-    constructor(httpClient) {
-        super(httpClient, '/assets');
-        this.addAttachment = (id, form) => {
-            const headers = Object.assign({}, form.getHeaders());
-            return this.httpClient.post(`${this.basePath}/${id}/attachment`, form, {
-                headers,
-                maxBodyLength: Infinity,
-                maxContentLength: Infinity,
-            });
-        };
-    }
-    deleteOne(id, force = false) {
-        return this.httpClient.delete(`${this.basePath}/${id}`, { params: { force } });
-    }
-    getChildren(assetId, params = {}) {
-        return this.getManyFiltered({ parent: assetId }, params);
-    }
-    getAttachments(assetId) {
-        return this.httpClient.get(`${this.basePath}/${assetId}/attachments`);
-    }
-    getEventLevelOverride(ids, causes) {
-        return this.httpClient.get(`${this.basePath}/eventcauses`, {
-            params: { ids: ids.join(','), causes: causes.join(',') },
-        });
-    }
-    updateEventCausesAsset(id, dto) {
-        return this.httpClient.put(`${this.basePath}/${id}/eventcauses`, dto);
-    }
-    getRevisions(assetId) {
-        return this.httpClient.get(`${this.basePath}/${assetId}/revisions`);
-    }
-    rollback(assetId, revisionId) {
-        return this.httpClient.put(`${this.basePath}/${assetId}/rollback`, { revisionId });
-    }
-    deleteRevision(assetId, revisionId) {
-        return this.httpClient.delete(`${this.basePath}/${assetId}/revisions/${revisionId}`);
-    }
-}
-exports.AssetService = AssetService;

package/dist/assettypes.service.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AssetTypesService = void 0;
-const tslib_1 = require("tslib");
-const ts_mixer_1 = require("ts-mixer");
-const api_base_1 = require("./api-base");
-const data_service_1 = require("./data.service");
-const trash_service_1 = require("./trash.service");
-let BaseService = class BaseService extends api_base_1.APIBase {
-};
-BaseService = tslib_1.__decorate([
-    (0, ts_mixer_1.mix)(data_service_1.DataService, trash_service_1.TrashService)
-], BaseService);
-class AssetTypesService extends BaseService {
-    constructor(httpClient) {
-        super(httpClient, '/assettypes');
-    }
-    getRevisions(id) {
-        return this.httpClient.get(`${this.basePath}/${id}/revisions`);
-    }
-    rollback(id, revisionId) {
-        return this.httpClient.put(`${this.basePath}/${id}/rollback`, { revisionId });
-    }
-    deleteRevision(id, revisionId) {
-        return this.httpClient.delete(`${this.basePath}/${id}/revisions/${revisionId}`);
-    }
-}
-exports.AssetTypesService = AssetTypesService;

package/dist/content.service.d.ts

@@ -1,23 +0,0 @@
-import FormData from 'form-data';
-import { Readable } from 'stream';
-import { APIBase } from './api-base';
-import { Content, ReturnType } from './content.interface';
-import { DataService } from './data.service';
-import { HttpClient } from './http.service';
-import { TrashService } from './trash.service';
-interface BaseService extends DataService<Content>, TrashService<Content> {
-}
-declare class BaseService extends APIBase {
-}
-export declare class ContentService extends BaseService {
-    constructor(httpClient: HttpClient);
-    upload: (form: FormData) => Promise<Content>;
-    download(id: string, raw?: boolean): Promise<Blob | ArrayBuffer>;
-    download(id: string, returnType: ReturnType.TEXT): Promise<string>;
-    download(id: string, returnType: ReturnType.JSON): Promise<Record<string, unknown>>;
-    download(id: string, returnType: ReturnType.NODEBUFFER): Promise<Buffer>;
-    download(id: string, returnType: ReturnType.BLOB): Promise<Blob>;
-    download(id: string, returnType: ReturnType.ARRAYBUFFER): Promise<ArrayBuffer>;
-    download(id: string, returnType: ReturnType.NODESTREAM): Promise<Readable>;
-}
-export {};

package/dist/content.service.js

@@ -1,50 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ContentService = void 0;
-const tslib_1 = require("tslib");
-const ts_mixer_1 = require("ts-mixer");
-const api_base_1 = require("./api-base");
-const content_interface_1 = require("./content.interface");
-const data_service_1 = require("./data.service");
-const trash_service_1 = require("./trash.service");
-let BaseService = class BaseService extends api_base_1.APIBase {
-};
-BaseService = tslib_1.__decorate([
-    (0, ts_mixer_1.mix)(data_service_1.DataService, trash_service_1.TrashService)
-], BaseService);
-class ContentService extends BaseService {
-    constructor(httpClient) {
-        super(httpClient, '/contents');
-        this.upload = (form) => {
-            const headers = Object.assign({}, form.getHeaders());
-            return this.httpClient.post(`${this.basePath}`, form, { headers, maxBodyLength: Infinity, maxContentLength: Infinity });
-        };
-    }
-    download(id, second) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            let returnType;
-            if (typeof second === 'boolean' || second == null) {
-                returnType = second ? content_interface_1.ReturnType.ARRAYBUFFER : content_interface_1.ReturnType.BLOB;
-            }
-            else {
-                returnType = second;
-            }
-            const url = `${this.basePath}/${id}/download`;
-            switch (returnType) {
-                case content_interface_1.ReturnType.TEXT:
-                    return this.httpClient.get(url, { responseType: 'text' });
-                case content_interface_1.ReturnType.JSON:
-                    return this.httpClient.get(url, { responseType: 'json' });
-                case content_interface_1.ReturnType.NODEBUFFER:
-                    return Buffer.from(new Uint8Array(yield this.httpClient.get(url, { responseType: 'arraybuffer' })));
-                case content_interface_1.ReturnType.BLOB:
-                    return this.httpClient.get(url, { responseType: 'blob' });
-                case content_interface_1.ReturnType.ARRAYBUFFER:
-                    return this.httpClient.get(url, { responseType: 'arraybuffer' });
-                case content_interface_1.ReturnType.NODESTREAM:
-                    return this.httpClient.get(url, { responseType: 'stream' });
-            }
-        });
-    }
-}
-exports.ContentService = ContentService;

package/dist/data.interface.d.ts

@@ -1,31 +0,0 @@
-export interface Paginated<T> {
-    docs: T;
-    total: number;
-    limit: number;
-    page?: number;
-    pages?: number;
-    offset?: number;
-}
-export interface RequestParameter {
-    filter?: string;
-    limit?: number;
-    page?: number;
-    populate?: string;
-    sort?: string;
-}
-interface TimePeriod {
-    from: Date;
-    to: Date;
-}
-export declare function instanceOfTimePeriod(object: any): object is TimePeriod;
-export type Filter = Record<string, string | string[] | TimePeriod>;
-export interface DataInterface<T> {
-    addOne(dto: any): Promise<T>;
-    addMany(dto: any[]): Promise<T[]>;
-    getOne(id: string, options?: any): Promise<T>;
-    getMany(params?: RequestParameter, parentId?: string): Promise<Paginated<T[]>>;
-    getManyFiltered(filter: Filter, params?: RequestParameter, parentId?: string): Promise<Paginated<T[]>>;
-    updateOne(id: string, dto: any): Promise<T>;
-    deleteOne(id: string): Promise<any>;
-}
-export {};

package/dist/data.interface.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.instanceOfTimePeriod = instanceOfTimePeriod;
-function instanceOfTimePeriod(object) {
-    return 'from' in object && 'to' in object;
-}